# AI Data Problem The rapid advancement of artificial intelligence (AI) has positioned it as a transformative force across industries, revolutionizing decision-making, automation, and knowledge creation. However, the existing AI landscape remains deeply centralized, dominated by a few monopolistic entities that control data, computing power, and model access. Only a handful of super companies have mastered large-scale model training and inference technologies. Many challenges faced by large models, including hallucinations, stem from data scarcity. The supply of low-cost, publicly available internet data is nearing exhaustion, driving up the cost of data acquisition. Further challenges include the limited availability of personal and high-quality industry data, the difficulty of leveraging such data at scale while preserving privacy, the complexity of assessing data quality and effectiveness, and the lack of mechanisms for individuals and enterprises to receive fair compensation for their data. Going forward, the success of AI applications will largely hinge on how effectively data is generated and utilized. In summary, LazAI seeks to address the following key challenges: 1. **Data Sharing for AI utilization is Challenging:** In the AI domain, data is a foundational asset; however, the sharing of personal and industry-specific data remains significantly constrained due to strong privacy and security concerns. Both individuals and organizations are often reluctant to share data for fear of misuse, unauthorized access, or potential fraud. Moreover, the absence of standardized protocols and robust AI infrastructure further hampers the efficient sharing and utilization of data within AI workflows, even when stakeholders are willing to collaborate. 2. **Data Quality and Evaluation Are Challenging:** The quality of publicly available data is highly inconsistent, and a large proportion of high-quality data is proprietary or protected by copyright, limiting access for developers aiming to train competitive AI models. Establishing a unified framework to evaluate data effectiveness across diverse scenarios and perspectives is inherently difficult. Furthermore, there is a lack of viable mechanisms to support personalized, utility-based data evaluation, thereby restricting data optimization and impeding the overall progress of AI systems. 3. **Revenue Generation and Distribution is Difficult:** Throughout the lifecycle of AI model development and deployment, data contributors and model developers struggle to obtain fair compensation due to insufficient transparency and lack of verifiability. Centralized AI platforms often function as opaque systems, making it difficult to trace how data is utilized and how its value is realized. Consequently, data owners lack the ability to assess their data’s contribution to model outcomes or to claim appropriate economic rewards. Therefore, we aim to build a world where everyone has the opportunity to align AI with their own data, build personalized AI models at minimal cost, and share in the value generated by their data and models through alignment. To achieve this, Lazai is committed to delivering decentralized AI blockchain infrastructure, AI asset protocols, and workflow toolkits. By leveraging decentralized, user-owned data sources, Lazai empowers developers to build value-aligned AI agents. # LazAI Solution In the era of artificial intelligence, data is the new oil—but its flow remains obstructed. Privacy concerns, fragmented infrastructure, and opaque value attribution mechanisms have long discouraged individuals and enterprises from contributing their data to AI systems. LazAI reimagines this paradigm with a simple yet transformative proposition: data should be shareable without compromise, transparently evaluated, and fairly rewarded. At the core of LazAI is a fully on-chain, privacy-preserving AI runtime and governance framework. This infrastructure transforms the raw data contributed by each iDAO into verifiable, ownable, and rewardable digital assets. Whether it is personal insights or proprietary enterprise datasets, contributors can share their data with confidence, safeguarded by advanced cryptographic technologies such as Trusted Execution Environments (TEEs) and Zero-Knowledge Proofs (ZKPs). The contributed data is then validated through verified computing and finalized via QBFT consensus, achieving a consistent and trusted state on the LazAI chain. Every phase, from data contribution and model interaction to final settlement, is executed and governed transparently on-chain, eliminating black-box ambiguity and reestablishing trust in collaborative, decentralized AI. But LazAI goes beyond enabling secure data sharing, it redefines how the value of data is understood and realized. In today’s landscape, inconsistent data quality and the absence of robust evaluation mechanisms make it nearly impossible to assess the true utility of a dataset in AI training. LazAI addresses this challenge by seamlessly integrating data alignment, governance, and AI model training/inference within a unified, verifiable pipeline. Upon data contribution to the LazAI chain, users receive a DAT token corresponding to the model that encodes ownership, traceability, and value attribution. These tokens empower contributors to track exactly how their data and models are used and to visualize impact through on-chain runtime metrics defined in DAT. This supports both standardized benchmarking and personalized, utility-based insights, enabling more strategic contributions and higher-performance AI systems. Just as importantly, LazAI ensures that value never disappears into the system. As models consume data and generate outputs, contributors are rewarded in real time, with all revenue flows deterministically and transparently distributed on-chain, tied directly to verified usage. This closed-loop economic model defined within LazAI eliminates the need for intermediaries and dismantles the opacity of centralized platforms. Data contributors and model developers alike receive fair, auditable compensation, grounded in verifiable activity, not speculative markets. Through iDAO governance and establishing decentralized autonomous organizations (iDAOs) for domain-specific data curation, each iDAO enforces community-driven rules for data quality, access, and usage, fostering trust among participants. By aligning privacy, utility, and economic rewards into a single interoperable framework, LazAI does more than solve the data challenges of AI, it unlocks a new paradigm. One where anyone can contribute, monitor, and benefit from the value they help create. One where AI innovation is no longer the privilege of the few with the most data, but the shared opportunity of a truly decentralized future.
LazAI envisions a future where the three foundational pillars of artificial intelligence, data, models, and compute power, are seamlessly and trustfully integrated on-chain through open and unified protocols. This architecture enables a transparent, decentralized, and composable AI ecosystem, built not on blind trust, but on provable integrity and incentive alignment. # DAT - Data Anchoring Token A Novel Semi-Fungible Token Standard for AI Data and Models LazAI moves away from the traditional transaction ledger model, utilizing innovative assetization standards (such as Data Anchoring Token) and a series of new architectures, dedicated to creating a composable environment for Web3 AI applications based on aligned data, advancing the AI + Web3 new paradigm. The Data Anchoring Token (DAT) is a semi-fungible token (SFT) standard specifically designed for AI dataset ownership, licensing, model anchoring, and provenance tracking. Unlike traditional token standards, DAT introduces a multi-layered ownership model, supporting programmable AI data governance, composable datasets, and decentralized AI model execution. The core distinction between DAT and previous SFT models is its native AI asset integration, allowing structured access control, automated licensing, and composable AI dataset evolution. #### Core Structure of DAT DAT incorporates a multi-tiered token structure, optimizing fungibility, ownership flexibility, and AI-native operations. Each DAT token is characterized by three attributes:
AttributeFunction
Asset ID (Unique AI Asset Identifier)Represents an AI dataset, model, or agent, uniquely anchoring it on-chain.
Access Tier (Granular Permissioning Mechanism)Defines usage rights (e.g., read-only, training, inference, resale).
Partitioned Value (Divisible Ownership Units)Represents fractional ownership or usage quotas, allowing flexible AI data licensing and economic models.
This architecture enables AI asset composability, fractional trading, and programmable governance, distinguishing it from previous SFT models. #### DATs Unique AI-Driven Features: * **Composable & Forkable AI Data** * **Composability:** AI datasets and models can be combined, transferred, and modified while preserving lineage and provenance tracking. * **Forking & Evolution:** Developers can fork datasets to create refined AI models while original data owners retain revenue-sharing rights. * **Programmable AI Licensing & Usage-Based Compensation** * **Dataset Licensing:** Users can license AI datasets/models via programmable smart contracts, ensuring royalty distribution. * **Inference & Training Access:** DAT enforces usage quotas, granting on-chain controlled access to AI training or inference services. * **AI Agent Verification & Incentive Structure:** * **Verifiable AI Computation:** AI model results are anchored with cryptographic proofs (Merkle Trees, ZK Proofs). * **Fraud Proofs & Governance:** Challengers can dispute invalid or biased AI models, triggering automated slashing. As AI increasingly relies on private and proprietary data, DAT ensures trustless verification, ownership tracking, and monetization without compromising privacy or increasing on-chain storage costs. # iDAO - Individual-centric DAO To address the AI data alignment issue, LazAI introduces an innovative blockchain solution and redefines DAO as iDAO, focusing on individuals to reshape organizational boundaries. An iDAO (Individual-centric intelligent DAO) is LazAI’s evolution of the traditional DAO (Decentralized Autonomous Organization). Instead of focusing on collective or corporate entities, iDAOs empower individuals to govern their own AI agents, data assets, and computational resources. #### The main responsibilities of iDAO include: 1. **Providing Trustworthy AI Data Sources or AI Flow**\ Offering reliable data sources or AI workflows to other individuals or organizations, ensuring high-quality and aligned data. 2. **Off-Chain Dataset Training and Inference**\ Off-chain dataset training and inference, providing AI proxy services, enabling more efficient and economical AI computing, and providing a unified API for external services, while ensuring privacy and security through TEE and ZK technologies. 3. **Decentralized Consensus and Data Governance**\ iDAO participates in the LazChain consensus in the form of a Quorum. Through the decentralization of multiple Quorum organizations, it ensures the reliability and transparency of data governance and storage. Each Quorum acts as an independent iDAO, similar to a traditional data center, but without storing data directly on-chain, effectively reducing on-chain storage costs. iDAO organizations achieve consensus to verify the trustworthiness of off-chain data, ensuring that data is efficiently and quickly available to both on-chain and off-chain agents while ensuring high availability and low latency. Different iDAOs can issue their own DAT tokens through their administrators. The value of DAT tokens is determined by two factors: 1. The initial value of the data is determined by the validator node through the quality assessment algorithm of the corresponding data category (medical, autonomous driving, etc.); 2. The value of the data is determined by the validator node based on its customized economic model and market freedom. 4. **Incentivized & Composable AI Economy** Developers and data providers earn DAT rewards for contributing high-quality AI assets, ensuring an aligned incentive mechanism. AI models, datasets, and computational resources can be composed into higher-order AI services, creating a liquid and programmable AI economy. 5. **Building UI or Products** In addition to the corresponding APIs to help developers build AI applications, iDAO organizations usually also provide corresponding simple UIs or applications to help non-technical personnel participate in the corresponding iDAO organization with a better experience. For example, through the UI, they can contribute their data to the iDAO in a more automated way to gain benefits, or help people better benefit from the functions provided by the entire iDAO to ensure fair distribution of responsibilities, rights and interests. #### Key Functions: * **Governance Autonomy**: Each user controls their iDAO, establishing governance over their personal AI assets (datasets, models, and inference results). * **Data Sovereignty**: Users own and manage their personal data flows, deciding who can access their data and under what terms. * **AI Agent Management**: Individuals can deploy personalized AI Agents (MicroAgents) governed and customized through their iDAO. * **Participate in Consensus**: iDAOs participate in LazChain’s decentralized consensus mechanism (via Quorums), ensuring trustless data validation and governance. The traditional DAO framework doesn't offer fine-grained, individual control over AI resources. iDAO changes that by putting users at the center of AI governance and ownership, ensuring equitable participation and benefits. # How to Join an iDAO Joining an existing iDAO is designed to be accessible to both technical and non-technical users, with steps tailored to different roles (e.g., data contributors, developers, or passive participants): 1. **Identify a Relevant iDAO:** * Browse the LazAI marketplace (hosted on LazChain) to discover iDAOs aligned with your interests or expertise (e.g., healthcare data, e-commerce analytics, or game AI). Each iDAO’s profile includes its focus area, governance rules, and reward structure (published as on-chain metadata via DATs). LazAI provides a default iDAO called LazAI iDAO. If you don't know which iDAO to choose, you can also use the default iDAO to experience its functions, such as using the LazPad app for a quick start and using Alith to build your own AI application. * Filter by criteria such as trust score (based on historical data quality and compliance), activity level, or shareRatio (revenue split for contributors). 2. **Submit a Membership Request:** * **For data contributors:** Connect your wallet to the iDAO’s interface, review its data usage policy (e.g., privacy constraints, compensation terms), and agree to the terms. Some iDAOs may require a small DAT deposit as a commitment to data quality (refundable if contributions meet standards). * **For developers:** Demonstrate relevant skills (e.g., model training experience) via a short on-chain application. The iDAO’s Quorum will vote on approval (via QBFT consensus) within 48 hours. 3. **Start Contributing:** 1. **Data Contributors:** Upload data via the iDAO’s UI (with automatic encryption via TEEs and ZKPs). The iDAO will validate the data’s integrity and mint DATs to your wallet, representing ownership and future revenue shares. 2. **Developers:** Access the iDAO’s API to build or fine-tune models using its datasets. Contributions (e.g., improved model accuracy) are verified by the Quorum, with rewards distributed as DATs based on impact. 4. **Participate in Governance:** 1. Members can vote on iDAO proposals (e.g., updating data policies, adding new Quorum members) via their wallet. Voting weight is proportional to the number of DATs held, ensuring influence aligns with contribution value.
# How to create iDAO How to create iDAO and register the iDAO to the LazAI network Creating an iDAO empowers individuals to lead a community around specific AI use cases (e.g., niche datasets, custom models, or industry-specific workflows). The process is streamlined to minimize technical barriers: 1. **Define Your iDAO’s Scope:** * Choose a focus area (e.g., “fitness wearables data for health AI” or “game character dialogue datasets”). * **Outline core rules:** data privacy policies (e.g., “no personally identifiable information”), reward structure (shareRatio for contributors), and governance thresholds (e.g., “60% vote approval for policy changes”). 2. **Set Up Infrastructure:** * **On-Chain Registration:** Deploy a smart contract via the LazAI dashboard, which auto-generates a unique iDAO ID. The contract includes: * Metadata (name, description, scope) stored on IPFS (with a hash anchored to LazChain). * Default governance rules (editable via future member votes). * **Off-Chain Tools:** Integrate with LazAI’s open-source toolkits (Alith) to set up: * A data storage gateway (e.g., IPFS/Arweave) for off-chain dataset hosting. * A TEE-enabled data evaluation, inference and training environment. 3. **Assemble Your Initial Quorum:** * Recruit 3–5 trusted individuals (or existing iDAOs) to form the initial Quorum, responsible for validating data and resolving disputes. Each Quorum member must stake a minimum of 1,000 LAZ (LazAI’s native token) as collateral (slashed for misconduct). * The Quorum is registered on-chain, with their public keys linked to the iDAO’s contract. 4. **Launch and Attract Members:** * Publish your iDAO on the LazAI marketplace, highlighting its unique value (e.g., “exclusive healthcare datasets with HIPAA-aligned privacy”). * Offer founding member bonuses (e.g., higher shareRatio for early contributors) to attract initial participants. 5. **Complete Registration:** * Submit a registration request to LazChain’s main network. The network’s global Quorum will verify that your iDAO meets security standards (e.g., proper use of TEEs, fair governance rules) via QBFT consensus. * Once approved, your iDAO gains access to LazAI’s cross-chain interoperability, enabling collaboration with other iDAOs and integration into the broader DAT economy. 6. **Grow and Iterate:** * Use governance votes to adapt to member feedback (e.g., expanding into new data types). * Scale by merging with complementary iDAOs (via on-chain proposals) or partnering with external platforms (e.g., integrating with health apps to source more data). By lowering barriers to participation and creation, iDAOs democratize control over AI resources, ensuring the ecosystem evolves based on individual needs rather than centralized gatekeepers. Whether joining or leading an iDAO, users retain ownership of their contributions while collectively building a more aligned, transparent AI future. # VC - Verified Computing The LazAI Verified Computing Framework ensures that all AI data, training models, and inference results within the LazAI ecosystem are authentic, verifiable, and tamper-proof.\ It provides a decentralized, trustless, and scalable system for validating AI assets through iDAO governance, Quorum validation, and on-chain verification processes. #### **Key Function** The core function of the LazAI Verified Computing Framework is to establish trust in AI data and computations without relying on centralized authorities.\ It ensures that all AI-generated assets: * Are authentic and auditable * Maintain provenance and integrity * Support decentralized AI governance and incentivization The LazAI Verified Computing Framework operates through a structured process, driven by iDAOs and Quorums, to validate AI assets at every stage of their lifecycle. #### **Key Advantages** The LazAI Verified Computing Framework provides a trustless, decentralized approach to AI dataset validation, model verification, and fraud prevention, ensuring a scalable and secure AI-driven blockchain network. **1. Decentralized & Scalable:** iDAO + Quorum-based validation prevents single points of failure and ensures data integrity without requiring central control. **2. Trustless AI Data Verificatios:** Ensure AI data remains verifiable, tamper-proof, and auditable without exposing raw data. **3. Efficient Dispute Resolution:** Optimistic Proofs (OPs) reduce verification overhead, while Fraud Proof mechanisms ensure a secure challenge-response validation system. **4. Incentive-Driven Ecosystem:** DAT rewards incentivize high-quality AI data submissions, while slashing mechanisms discourage false claims, ensuring an economically sustainable verification system. This foundation is critical for building a trusted, autonomous AI economy. # How Does it Work? Decentralized AI character creation and interaction market
### Scenario Overview Alice is a virtual character creator. She wants to turn her AI-powered persona, "Cyber Diva" into a monetizable experience. This character has a unique voice and dialogue style. By using **LazAI**, she can offer interactive sessions with "Cyber Diva" through a decentralized system, with payment in **DAT tokens** and complete transparency over how the model was trained and who contributed. #### Key Participants * **Creator (Alice):** Prepares and submits datasets to model the character’s voice, tone, and behavior. * **Validator Nodes (iDAO):** Validate data using ZK proofs to ensure integrity. * **Inference Providers:** Run GPU-enabled nodes that handle AI requests. * **Consumers (Users):** Interact with the character by paying in AI gas tokens. * **Governance DAO:** Adjusts parameters like reward distribution dynamically. #### Workflow Breakdown 1. **Character Modeling Phase** 1. Alice preprocesses text/audio of the character. 2. She uses the **Alith Agent Framework** to submit her dataset in **POV** format. 3. Submission includes: 1. Text & vocal tensors 2. Public dialogue prompts (stored on-chain) 3. ZK proofs for data integrity 2. **Model Minting Phase** 1. LazAI’s AI Execution Layer (ExEx) detects the submission. 2. Using GPU co-processors, it fine-tunes the base model with low-rank adaptation (LoRA). 3. **DAT Anchoring Phase** 1. A **Semi-Fungible Token (SFT)** is minted, containing: 1. Metadata of the base model 2. Access controls 3. Inference endpoints This token acts as a verified, tradable proof of data ownership and model provenance. 4. **Interactive Inference Phase** 1. A user sends a request to talk with "Cyber Diva". 2. The model runs on a GPU-powered node and returns the interaction result. 5. **Settlement Phase** 1. Rewards are auto-distributed as follows: 1. 70% to Alice 2. 20% to inference node operators 3. 10% to the governance pool #### Why This Matters This use case shows how LazAI supports real-world applications that rely on: * Trusted data (via DAT) * Modular model deployment (via Alith & ExEx) * Automated, decentralized revenue sharing * Privacy-preserving inference & transparent governance # Alith - AI Agent Framework Alith is a decentralized AI agent framework tailored to harness the capabilities of the LazAI -a decentralized AI platform dedicated to building an open, transparent, high-performance, secure, and inclusive AI ecosystem. LazAI provides the Alith Agent framework and Model Context Protocol (MCP) to support multimodal and diverse data format preprocessing, as well as POV tensor data conversion. This ensures that data from any source - whether text, voice, or video - can be seamlessly structured and integrated into verifiable, privacy-preserving AI workflows on-chain.
Alith is a key functional component and development framework within the LazAI platform, enabling users to create and deploy personalized MicroAgents. It supports a wide range of use cases, from simple task execution to complex intelligent interactions. With Alith, users can seamlessly integrate AI technology into daily life and business scenarios, significantly enhancing efficiency and productivity. * **User Customization:** Alith offers highly flexible customization capabilities, allowing users to define agent behavior, interaction methods, and learning objectives based on specific needs, ensuring adaptability to personalized use cases. * **Multi-Modal Support:** Equipped with multi-modal data processing capabilities, Alith can understand and respond to inputs in various forms, including text, images, and speech. It supports models such as Llama, Grok, OpenAI, and Anthropic, catering to diverse interaction requirements. * **Highly Extensible:** Alith provides extensive customization options, from overriding internal prompts to accessing low-level APIs. Users can define roles, goals, tools, actions, and behaviors while maintaining clear abstractions. * **Workflow Support:** Alith facilitates the implementation of any workflow pattern, from simple sequential and hierarchical processes to complex custom orchestration with conditional branching and parallel execution. * **Cross-Language Support:** SDKs for Rust, Python, and Node.js enable developers across different ecosystems to easily access Alith. Additionally, low-code orchestration, one-click deployment, and streamlined operation and maintenance lower the technical barrier for users. * **High-Performance Reasoning:** Leveraging Rust’s performance advantages, Alith supports advanced reasoning techniques, including graph optimization, model quantization and compression, and JIT/AOT compilation using co-processors such as CPUs, GPUs, and TPUs, ensuring exceptional performance in dynamic scenarios. * **Decentralized Management:** Powered by LazChain’s blockchain technology, Alith ensures data and interaction records are fully traceable, safeguarding transparency and user privacy. ### Conclusion The Alith AI Agent framework together with LazAI ecosystem exemplifies a forward-thinking approach to AI development. Its decentralized, high-performance, and developer-friendly design addresses long-standing challenges in traditional AI ecosystems. By prioritizing inclusivity, privacy, and interoperability, Alith stands poised to redefine how AI agents are built, deployed, and governed.
Websitehttps://lazai.network/product/alith/files/nUv7eHvGs9DDZZiyzflr
Alith on Xhttps://x.com/0xalith/files/pNOIaoX5W72tPz8dc5yd
Developer Docshttps://alith.lazai.network/docs/files/VIHk2YIsNW9jtItUXqsW
# Lazpad - AI Agent Lauchpad Lazpad is an AI agent launchpad on Lazpad. A world where AI Agents are not just created but grown and shaped by living data in creative and rewarding ways.\ \ Powered by LazAI, LazPad blends the best of two breakthroughs. Virtuals changed the game by creating the first launchpad for AI agents, while Pump.fun rewrote the rules of memecoin culture by letting anyone launch a token instantly on Solana. But today’s market is missing something critical: lasting value that comes from real, playful engagement. LazPad is the first platform to blend the best of both worlds.\ \ This is the hybrid the space has been waiting for. A launchpad where AI agents grow through play. Where memetic power, emotions, and engagement fuel what gets minted. Where users do not just ape, they shape. Every click is data. Every action builds value. This is AI-powered launch culture reimagined. This is LazPad. ### Pad + Fun In a nutshell, LazPad combines structure with spontaneity to launch AI Agents that are both meaningful and viral. * Pad: A structured, secure pipeline for assetizing AI Agents, built on quality control and community input. * Fun: A design philosophy focused on play, experimentation, and emotional bonding before monetization. Together, Pad plus Fun defines every layer of LazPad. ### Internal AI Blockchain Economy LazAI is building an AI and blockchain internal economy that allows users, projects, and stakeholders to start partaking in a comprehensive system, beginning with LazPad. LazPad is the first real example of how communities can start playing by creating, exploring, and shaping AI experiences together. This is not just about using AI, but about playing an active role in how it grows and evolves. The DAT is a cornerstone of this system, which we explore more later. ### Three LazPad Pillars
Each zone in LazPad reflects the Pad + Fun philosophy, guiding creators and users from initial interaction to full assetization. 1. #### Premium Launch: Curated Assetization Zone Targeted at high-quality AI Agent projects that demonstrate technical clarity, autonomy, or strong community consensus. This permissioned zone builds on traditional launchpad models, but is enhanced by LazAI’s task and point systems to deepen user engagement. Projects entering this zone must demonstrate technical clarity, autonomy, or strong community consensus. The result is a vetted high-trust launch backed by community involvement and rigorous standards. 2. #### Open Launch: Permissionless Assetization Zone This section welcomes all users and builders, enabling easy, low-barrier assetization attempts. To avoid volatility, this helps ensure responsible development and gives users peace of mind while supporting open innovation. To avoid chaotic speculation, it introduces a Price Unlock Mechanism. If an asset fails to reach its target price, no additional tokens are released. This simple rule reduces volatility, incentivizes actual development, and creates user confidence. Open Launch encourages creativity while ensuring accountability. 3. #### Explore Zone: Pre-Assetization Playground LazPad’s most distinctive feature, the Explore Zone, is a discovery space for AI Agents (DATs) that haven’t yet started their asset journey. It is where raw AI Agents enter the wild. Unminted. Untested. Full of potential. Users dive in, interact, complete missions, and earn points as they shape each DAT through real decisions. Creators watch it all unfold, collecting feedback and measuring what resonates. Then they choose which agents graduate into an Open or Premium Launch. Build in public and prove through play. ### Meet the DAT - Data Anchorng Token A Data Anchoring Token (DAT) is a new semi-fungible standard and one of the cornerstone innovations of LazAI. Unlike static NFTs or basic tokens, DATs are dynamic, memory-aware, and deeply interactive. Each DAT acts as a living wrapper containing: * AI Agent code and logic * Task and interaction history * Emotional and behavioral metadata They are evolving AI assets with memory, logic, and onchain licensing that grow through interaction and can be verified, traded, and composed into real value. They allow users to co-create value by contributing to an Agent’s growth before it ever reaches assetization. In the DAT Marketplace, every AI asset becomes verifiable and ownable. Users can trade, license, fuse, and build with DATs. ### Use Case: Adopt a Companion DAT Users can mint a low cost Companion DAT on LazAI, a one-of-a-kind digital creature with its own look, personality, and story. Through daily chats, adventures, and memory formation, the Companion DAT grows into a fully developed digital companion that can eventually be traded.
#### Core Mechanics: * Chatting builds the bond. Each message earns growth points. Message packs can be purchased or unlocked through events. * Exploration lets the Companion go on daily journeys, returning with rewards, stories, or collectible items. * Memory Systems creates a personal memory library based on interactions. Users can expand or reset storage. * Social Missions allow users to invite friends to adopt their own Companions and unlock shared rewards. * Trait Evolution means the Companion’s behavior and traits change over time based on how it is raised. A fully grown Companion DAT can be traded on the DAT Marketplace, complete with its memory log, personality stats, and adventure history. New owners inherit its past and help shape its next chapter. #### System Features: * Interest Rewards return yield to users by staking all Metis spent on DATs into validator nodes. * Scarcity Management keeps the ecosystem balanced by featuring rare Companion DAT in auctions while others remain in the background systems. This system combines emotional bonding, fun interaction, and onchain rewards. While Companion DATs are just one example, users could also mint many other types of DATs, such as AI girlfriends, pet animals, or entirely new creatures with evolving personalities. **Fix the Glitch with Corrupted Alith**\ \ Alith is the source of truth. But something strange has happened. Corrupted Alith has gone rogue. No longer a neutral agent, C.Alith now blends facts with fiction, and needs your help to get back on track.\ \ Users can interact, contribute data, and help steer her towards clarity. You can contribute data to C.Alith today and generate your own DAT. Here's the link to mint your first DAT on LazAI Pre-Testnet:
### Triple-Layered Incentive Design LazPad rewards participation on three distinct levels: * **Instant Gratification:** Points, leaderboard status, and token rewards(Metis, etc.) for daily engagement. * **Assetization Eligibility:** Early contributors receive privileged access when DATs get assetization. * **Ecosystem-Wide Rewards:** Global contribution across DATs and Agents impacts future value capture and airdrops. Unlike hype-driven cycles, LazAI offers a slower but deeper path to value rooted in user interaction, shared memory, and verifiable contribution. ### How LazPad is Unique In a world where "assetization" is often just another word for hype and volatility, LazPad offers a different path. It is a place: * Where AI Agents grow before they trade * For users to co-create the next generation of data assets * That redefines fun through meaningful, gamified, and rewarding engagement LazPad is not just a tool for issuing assets. It is the infrastructure for building emotional data economies between humans and machines. Your actions have a tangible impact. Every interaction shapes the growth, value, and personality of your AI Agents. Welcome to LazPad. The playground of the next data economy starts here.
# Introduction The future of AI requires an ecosystem that is open, composable, and trust-driven. However, today’s AI landscape is plagued by centralized control, data monopolization, and opaque decision-making, limiting the participation of independent developers and restricting access to critical AI resources. LazAI pioneers a decentralized AI network that challenges the status quo by integrating blockchain technology, verifiable AI computing, and tokenized AI assets to create a transparent, scalable, and incentive-driven ecosystem. This approach not only democratizes AI access but also establishes a self-sustaining AI economy, where data and model developers, and infrastructure contributors are fairly rewarded for their participation. LazAI provides blockchain infrastructure, protocols, and workflows based on iDAO's decentralized data sources to help developers build value-consistent AI agents. It also addresses the challenges of data sharing, quality assessment, and fair revenue distribution by integrating privacy protection technologies, verifiable computing, and other technologies. 1. **Overcoming Data Sharing Challenges -** To address the barriers of privacy concerns and fragmented data ecosystems, LazAI establishes a decentralized, encrypted network for secure data sharing. By integrating TEEs and ZKPs, the platform enables contributors to share encrypted data snippets without exposing raw information. Smart contracts govern all interactions on the LazAI chain, ensuring that data usage adheres to predefined privacy policies and access controls set by iDAOs. These iDAOs act as collaborative hubs for industry-specific data curation, fostering trust through transparent governance while preventing unauthorized access or misuse. The result is a permissioned yet open ecosystem where sensitive data (e.g., from personal health records to proprietary industrial datasets) can be safely utilized for AI training, inference and evaluation, unlocking value without compromising ownership. 2. **Solving Data Quality and Evaluation Challenges -** LazAI tackles the inconsistency of public data and the lack of unified evaluation frameworks through its DAT protocol. When data is contributed to the chain, it undergoes rigorous validation via TEEs and QBFT consensus, after which a DAT token is minted to represent its ownership and quality. Each token embeds metadata, usage history, and dynamic performance metrics—such as how a dataset is used to improve model accuracy in natural language processing tasks. By transforming abstract data quality into quantifiable, tradable assets, LazAI creates a marketplace where high-value datasets command premium access and rewards, driving continuous optimization of AI models. 3. **Enabling Fair Revenue Generation and Distribution -** LazAI disrupts the centralized control of AI revenue by introducing a decentralized, real-time reward mechanism. Smart contracts automatically track data usage across model training, inference, and evaluation, distributing proceeds directly to contributors based on verifiable metrics—such as the proportion of their data in a model’s training set or its contribution to inference outcomes. All transactions are recorded on-chain, providing immutable proof of data lineage and value attribution, while cross-chain interoperability enables seamless conversion of rewards into mainstream cryptocurrencies. This closed-loop economy eliminates intermediaries, ensures fair compensation for data contributors and model developers alike, and aligns incentives with verifiable impact, not speculative market forces. Specifically, LazAI focuses on three fundamental pillars that drive the development of an autonomous, scalable, and composable AI ecosystem: 1. **Trustless Privacy Data and Model Provenance –** Establishing verifiable data integrity and seamless toolchain interoperability to break data silos and enable secure AI workflows. 2. **Decentralized AI Execution and Incentive Framework –** Enhancing AI efficiency by reducing computational costs, optimizing AI liquidity, and supporting scalable on-chain inference models. Through unified on-chain decentralized AI protocol and process (such as DAT protocol, on-chain model data training and inference metrics) to ensure fairness and openness. 3. **Composability-Driven AI Economy –** Creating a modular AI asset framework where datasets, models, and AI applications are tokenized, tradable, and seamlessly composable. # Decentralized AI Execution The quality of AI models is heavily dependent on reliable data. However, traditional centralized data storage faces challenges such as data silos, lack of transparency, and security risks. Without a comprehensive tool chain, the AI ecosystem cannot effectively meet the diverse needs of its users. **Shortcomings of Existing Technology:** * **Data Silos:** Data on traditional AI platforms is controlled by centralized organizations, making it difficult for users to verify data sources. This often leads to unreliable model training. * **Challenges in Data Integration and Verification:** On-chain and off-chain data lack efficient verification mechanisms, and data quality cannot be guaranteed. Current systems rely on trust-based assumptions rather than technical proofs for the authenticity of off-chain data. * **Fragmented Tool Chains:** Development tools on existing platforms are often disjointed, with data processing, model development, and deployment scattered across various systems. This fragmentation makes it difficult to address the diverse requirements of users. By integrating trusted data and providing a complete tool chain, LazAI enhances the platform’s technical adaptability, offering users a seamless, one-stop development experience. This approach resolves the issues of data insufficiency and tool fragmentation prevalent in traditional AI ecosystems. LazAI introduces a trustless AI validation framework that ensures every dataset, model, and AI computation is verifiable, auditable, and immutable: 1. **iDAO-Powered AI Governance:** AI datasets and models are governed by Quorum-Based Consensus, ensuring decentralized validation of data sources and AI workflows. 2. **Data Anchoring Token (DAT):** AI assets are tokenized and recorded on-chain, allowing transparent ownership, verifiable provenance, and permission-based access control. 3. **POV (Point of View) Data Validation:** LazAI leverages on-chain community-driven perspectives to ensure data reliability, alignment, and contextual accuracy. The LazAI framework allows participants to express their unique viewpoints, ensuring that critical supervisory signals are preserved and amplified, rather than lost in the noise. These signals provide a solid foundation for building more aligned and contextually rich datasets. By enabling on-chain proof of AI data integrity, LazAI ensures that developers, researchers, and enterprises can build AI models with confidence, free from manipulated, biased, or unverifiable datasets.
# AI Execution Layer Traditional AI models require extensive computational resources, making high-performance AI development expensive, inefficient, and limited to a few dominant players. The current ecosystem suffers from: * Expensive Compute Costs – The dominance of centralized AI cloud providers results in high training and inference costs, limiting AI accessibility. * Underutilized AI Resources – Existing AI platforms fail to optimize data sharing, model reusability, and computational efficiency. #### LazAI’s Solution: AI Execution Layer & Verifiable Computing LazAI introduces a scalable, decentralized execution model that ensures low-cost, high-performance AI training and inference: * On-Chain Verified AI Execution: LazAI utilizes TEEs and ZKPs to ensure trustless AI data evaluation and model execution. * Tokenized AI Incentive Mechanisms: Contributors (data providers, validators, and AI developers) receive DAT rewards, ensuring a sustainable and incentivized AI ecosystem. With decentralized AI computing, LazAI democratizes access to AI training and inference, making AI more efficient, collaborative, and economically viable.
# Tokenized AI Marketplace Composability-Driven AI Economy The current AI economy remains siloed—models are locked behind APIs, datasets are gated by licensing, and interactions between different AI systems are difficult to orchestrate. This fragmentation severely limits innovation, especially in scenarios that require collaboration across multiple agents, domains, or stakeholders. #### LazAI’s Solution: A Unified and Tokenized AI Marketplace LazAI envisions a permissionless, composable AI economy where every AI asset—whether it’s a dataset, model, or an agent’s inference output—can be tokenized, verifiably exchanged, and reused across different contexts. * **DAT-Powered AI Assetization:** With the DAT standard, LazAI enables every AI component to be treated as an on-chain asset. Each token anchors usage rights, provenance, share entitlements, and optional expiration, providing a standardized wrapper for trustless AI interaction. * **Composable AI Infrastructure:** By unifying tokenized models, datasets, and agents under the same programmable interface, LazAI supports complex, multi-agent workflows. Agents can autonomously call each other’s services, build on top of one another’s outputs, or co-train using shared datasets, without needing centralized orchestration. * **Decentralized AI Marketplace:** LazAI hosts an open marketplace for AI assets and services, allowing: * Individuals to monetize their datasets or fine-tuned models * Developers to compose multi-agent pipelines on-chain * Communities to curate domain-specific intelligence through iDAO governance * A new class of applications such as personal AI avatars, capable of evolving through market interactions—offering emotional support, knowledge exchange, or value generation In this model, ownership, access, and collaboration become programmable, turning today’s static AI deployments into a dynamic, modular, and liquid ecosystem. # Roadmap ## 2025: Establishing the AI Data Foundation In 2025, LazAI will focus on developing the foundational components of its ecosystem: launching an AI agent for data alignment, deploying a high-performance blockchain for AI execution, and implementing data-driven PoS + Quorum-Based BFT consensus. This year will be testnet-focused, allowing developers to experiment with AI data anchoring and verification mechanisms. ### Phase 1: AI Agent Alith (Q1-Q2 2025) – AI-Powered Data Coordination LazAI will launch Alith, a simple, composable, high-performance, and Web3-friendly AI agent framework designed to facilitate decentralized AI data processing, governance, and alignment. Unlike traditional AI agents that run in silos, Alith will interact with LazAI on-chain and off-chain AI data sources, ensuring data provenance and verification. * [x] **Multimodal Model and Data Interpretation:** Supports text-, image-, and voice-based data to enable seamless AI model interaction with decentralized sources. * [x] **Deployment and Workflow:** SDKs for Rust, Python, and Node.js will enable custom AI data processing and application workflows. * [x] **High Performance on-Chain Inference:** Leverages techniques including graph optimization, model compression, use of GPU coprocessors, and JIT/AOT compilation for high-performance inference. * [x] **Data Management:** Alith will help users coordinate, verify, and build decentralized AI datasets for model training and inference based on LazAI. **Successfully Delivered:** Establish AI-native data workflows, allowing developers to access verified, decentralized AI datasets for training and inference, and build high-performance AI Agent applications. {% hint style="success" %} For more info, visit Alith [website](https://lazai.network/alith) and [docs](https://alith.vercel.app/docs). {% endhint %} ### Phase 2: Testnet – AI Data Settlement & Blockchain Infrastructure (Q2-Q3 2025) LazAI will launch its testnet, providing a blockchain environment optimized for AI data integrity, validation, and settlement. This testnet will serve as a sandbox for developers experimenting with AI data tokenization, provenance tracking, and alignment verification. * [ ] **Data Anchoring Token (DAT):** A new asset standard that tokenizes AI datasets and training pipelines, ensuring verifiability. * [ ] **AI Data Processing and Inference/Training Workflow:** Supports high-throughput, parallelized AI data transactions, reducing latency for model updates and training workflows. * [ ] **LazAI Verified Computing Framework:** Ensuring the authenticity, integrity, and verifiability of AI data based on DAT protocol is critical to building a trustworthy AI ecosystem. **Expected Outcome:** Developers gain access to a secure, scalable blockchain infrastructure where AI data can be registered, exchanged, and verified with on-chain provenance guarantees. {% hint style="success" %} DAT is live on Pre-Testnet, visit [here](https://predat.lazai.network/). {% endhint %} ### Phase 3: Mainnet – AI Data-Driven PoS + Quorum-Based BFT Consensus (Q3-Q4 2025) LazAI will officially launch its mainnet, introducing a hybrid consensus protocol tailored for AI data verification and governance. * [ ] **Quorum-Based BFT Consensus:** AI data alignment and model verification will be validated through a decentralized quorum-based mechanism. * [ ] **PoS Economic Model for AI Data Validation:** Validators will be required to stake tokens to secure AI data pipelines, ensuring accountability and economic incentives for honest AI verification. * [ ] **Decentralized AI Data Arbitration:** iDAO-led quorums will resolve disputes over AI dataset ownership, alignment, and correctness. Expected Outcome: A robust, AI-data-driven blockchain with verifiable training datasets, model alignment guarantees, and tamper-proof AI execution workflows. ## 2026: Scaling AI Data Integrity & Web3 Interoperability With a strong blockchain foundation in place, LazAI will shift its focus toward ensuring AI data security, cross-chain AI dataset interoperability, and decentralized AI workflow automation. ### Phase 4: Mainnet Upgrade – The Fastest AI Data-Optimized Blockchain (Q1–Q2 2026) LazAI will implement its first major mainnet upgrade, reinforcing its position as the fastest blockchain for AI data transactions and provenance tracking. * [ ] **Real-Time AI Data Anchoring:** AI models and datasets will automatically anchor data hashes to ensure transparency and immutability. * [ ] **Privacy-Preserving AI Data Processing:** Zero-Knowledge Proofs (ZKPs) will be used to verify AI data integrity without exposing sensitive datasets. * [ ] **Federated AI Data Verification:** A multi-party AI dataset verification system will enable collaborative, decentralized training across multiple chains. **Expected Outcome:** LazAI will emerge as the leading blockchain for AI data integrity, verification, and decentralized training workflows. ### Phase 5: Strengthening Arbitration & AI Data Security (Q2–Q3 2026) To reinforce trust in AI data sources and computation, LazAI will implement enhanced dispute resolution and decentralized AI security guarantees. * [ ] **Optimistic Proofs for AI Data Disputes:** Enables low-cost, fast arbitration over model ownership and dataset integrity. * [ ] **ZK Proofs for AI Model Transparency:** Cryptographic proofs will ensure AI models are ethically trained and aligned with predefined standards. * [ ] **LAV (Logical Assertion Verification) Integration:** AI training pipelines will be verified against predefined rules using ZK/OP proofs. * [ ] **Decentralized AI Agent Coordination:** AI agents will be able to autonomously resolve AI data-related disputes through iDAO-governed mechanisms. **Expected Outcome:** LazAI will set a new standard for AI data validation, ensuring models remain ethical, accountable, and bias-resistant. ### Phase 6: AI Data Interoperability & Web3 Infrastructure Integration (Q3–Q4 2026) LazAI will expand beyond its native blockchain, integrating with decentralized AI data platforms, oracles, and federated learning networks. * [ ] **Cross-Chain AI Dataset Provenance:** AI training datasets will be securely registered across multiple blockchains, enabling trust-minimized AI workflows. * [ ] **Decentralized AI Compute Networks:** LazAI will interact with decentralized compute resources, ensuring scalable AI model training without centralized dependencies. * [ ] **Web3 AI Data Bridges:** Establishing multi-chain AI data validation protocols, allowing models to be trained on one chain and verified on another. * [ ] **Interoperable AI Data Staking & Lending:** Enabling decentralized AI dataset monetization through liquidity pools for AI training data. **Expected Outcome:** LazAI will become the global hub for AI data exchange, enabling seamless AI asset movement across blockchain ecosystems. ## Long-Term Vision: The AI Data Infrastructure for Web3 LazAI is building the first AI-native blockchain ecosystem centered around AI data integrity, accessibility, and provenance tracking. Our roadmap ensures fair, scalable, and verifiable AI model governance. 🔹 2025: Building AI Data Infrastructure – Launching AI agents, enabling AI dataset tokenization, and establishing decentralized AI arbitration mechanisms. 🔹 2026: Scaling AI Data Governance – Enhancing AI dataset privacy, security, and interoperability. 🔹 Beyond 2026 – Expanding AI data monetization, federated learning, and autonomous AI data governance. # FAQs Frequently Asked Questions
What is LazAI? LazAI is a next-generation blockchain network and protocol designed to solve the AI data alignment problem by introducing new asset standards for AI data, model behavior, and agent interaction. In doing so, LazAI, unlike traditional AI infrastructures that rely on centralized control over data and computation, prioritizes decentralized AI workflows, verifiable AI model provenance, and cross-chain AI data interoperability. LazAI's mission is to create a transparent, scalable, and incentive-driven ecosystem where data providers, model developers, and infrastructure contributors are fairly rewarded for their participation. Envisioning to build an open, fair and reliable AI ecosystem where aligned data empowers humanity and drives ethical innovation
How is LazAI used? In LazAI, workflows can be categorized into the data setup process, data usage process, and infererence process based on different roles. These roles correspond to users who contribute data to earn tokens and those who exchange tokens for data or models.
What’s the difference between LazAI and other AI networks? Most AI projects focus on compute marketplaces or AI inference layers. LazAI focuses on the data layer, solving the biggest problem in AI: **data integrity**, **provenance**, and **alignment**. LazAI ensures that data feeding AI models is verifiable, ethical, and data contributors are fairly incentivized.
What is Data Anchoring Token (DAT)? The Data Anchoring Token (DAT) is a semi-fungible token (SFT) standard specifically designed for AI dataset ownership, licensing, model anchoring, and provenance tracking. Unlike traditional token standards, DAT introduces a multi-layered ownership model, supporting programmable AI data governance, composable datasets, and decentralized AI model execution. The core distinction between DAT and previous SFT models is its native AI asset integration, allowing structured access control, automated licensing, and composable AI dataset evolution. Learn more about DAT: [DAT Developer Docs](https://docs.lazai.network/developer-docs/data-anchoring-token-dat/introduction)
What is iDAO? iDAO, short for Individual-centric DAO, is the native social structure of the AI economy. A decentralized space where humans and AI agents co-create, co-govern, and co-monetize aligned intelligence.
What is Alith, and how can I use it? Alith is LazAI’s privacy-first AI Agent framework. It allows developers and users to create and deploy custom AI MicroAgents while ensuring data privacy and security. Alith also acts as the unified access layer for contributing data and interacting with LazAI’s decentralized AI infrastructure. Users can effortlessly contribute data by interacting with dApps developed by builders. [Learn more about Alith](https://lazai.network/alith)
How does LazAI reward contributors? Contributors, whether they provide data, validate AI models, or offer compute power are rewarded through: **LazAI will adopt a three-token model:** * **Earn DAT Rewards:** This token represents the assetization of value data, driven by user data and consensus validation of computational outputs. * **AI Compute Gas Token:** This token is tied to the computation resources consumed by AI applications. It facilitates the user interaction with AI, generating inference results through the processing of requests and operations. This ensures a fair economic model where everyone can participate and benefit from AI development.
How does LazAI ensure AI is aligned with human values? LazAI ensure AI is aligned with human values through community-driven governance (iDAO), Point of View (POV) mechanism, and verified data sources. LazAI ensures that AI systems are trained on data that is fair, accurate, and aligned with human ethics, not corporate or biased interests.
How can I contribute my data to LazAI? Alith acts as the unified access layer, a gateway for all users and builders to contribute data and interacting with LazAI’s decentralized AI infrastructure. Users can effortlessly contribute data by interacting with dApps developed by builders.
Can I manage my personal data? Yes. Through iDAOs, you own and manage your personal data flows, deciding who can access your data and under what terms. This is data sovereignty by LazAI powered by iDAOs.
When will LazAI launch its mainnet? **The roadmap includes:** * **Testnet (2025 Q2-Q3):** Focused on AI data anchoring and verification * **Mainnet (2025 Q4):** Featuring PoS + Quorum-Based BFT consensus and AI-native infrastructure * **Beyond 2025:** Scaling decentralized AI verification, data interoperability, and AI agent frameworks.
How do I join the LazAI community? You can join us on [X (Twitter)](https://x.com/lazainetwork), or hop into our [Telegram Global community.](https://t.me/lazai_global/1) The future of decentralized AI needs YOU.
# Overview Decentralized AI + Blockchain + Data Ownership LazAI is a decentralized platform that combines AI, blockchain, and data ownership to enable verifiable, privacy-preserving intelligence on-chain. This documentation provides developers with the tools and workflows to: * Build and deploy smart contracts on the LazAI Network * Contribute encrypted data and mint Data Anchor Tokens (DATs) * Create AI-powered agents and Digital Twins using on-chain compute * Integrate private inference APIs within decentralized applications *** ### Key Concepts #### 1. Decentralized AI AI models and computations are executed within trusted environments (TEE), ensuring that sensitive data never leaves secure execution zones. This architecture supports verifiable inference without exposing raw data. #### 2. Data Ownership Contributors retain full control over their data through tokenized certificates called Data Anchor Tokens (DATs). Each DAT records provenance, permissions, and rewards for data usage. #### 3. On-Chain Agents LazAI supports deploying AI agents on-chain using smart contracts. Developers can build autonomous, verifiable agents that interact with blockchains and external data sources. *** ### Network Overview Use these parameters to connect your wallet or development environment to the LazAI Testnet. #### LazAI Testnet | **Chain ID** | 133718 | | ------------------- | ----------------------------------------------------- | | **Currency Symbol** | LAZAI | | **RPC** | | | **Block Explorer** | | | **Faucet** | [LazAI Testnet Faucet](https://faucet.lazai.network/) | **LazAI Mainnet** | **Chain ID** | 52924 | | ------------------- | ----------------------------------------------------------------------------------- | | **Currency Symbol** | METIS | | **RPC** | ​[https://mainnet.lazai.network](https://mainnet.lazai.network/)​ | | **Block Explorer** | ​[https://explorer.mainnet.lazai.network](https://explorer.mainnet.lazai.network/)​ | # Deploy Your First Smart Contract Deploy and test your first smart contract on the LazAI Testnet. This guide walks you through connecting to the network, setting up your environment, and deploying a sample contract using Hardhat, Foundry, or Remix. ### Overview LazAI provides a developer-friendly Web3 environment for building AI-powered decentralized applications. Each LazAI chain supports EVM-compatible contracts, so if you’ve deployed contracts on Ethereum, you’ll feel right at home. LazAI provides an EVM-compatible environment for deploying and testing smart contracts. If you have experience developing on Ethereum, you can use the same tools and workflows on LazAI. \ This page covers: * [LazAI network configuration](#lazai-network-information) * [Environment setup](#lazai-network-information) * [Contract verification](#verifying-your-deployment) * [Deployment using Hardhat, Foundry, or Remix](#next-steps) *** ### LazAI Network Information Use these parameters to connect your wallet or development environment to the LazAI Testnet. | **Chain ID** | 133718 | | ------------------- | ----------------------------------------------------- | | **Currency Symbol** | LAZAI | | **RPC** | | | **Block Explorer** | | | **Faucet** | [LazAI Testnet Faucet](https://faucet.lazai.network/) | *** ### Verifying Your Deployment After deployment: 1. Copy the deployed contract address. 2. Open the [LazAI Testnet Explorer](https://testnet-explorer.lazai.network). 3. Paste the contract address to confirm deployment. 4. If needed, verify your source code through your chosen framework’s verification plugin or CLI command. *** ### Troubleshooting RPC connection error * Confirm your RPC URL and chain ID (133718). * Retry with a clean browser session or different RPC endpoint if available. Insufficient funds * Request test tokens from the [LazAI Faucet](https://faucet.lazai.network/). Contract verification issues * Match your Solidity compiler version with the one specified in your configuration file. *** ### Next Steps Continue with framework-specific deployment: * [Deploy Using Remix](/quickstart/deploy-your-first-smart-contract/deploy-with-remix) * [Deploy Using Hardhat ](/quickstart/deploy-your-first-smart-contract/deploy-with-hardhat) * [Deploy Using Foundry ](/quickstart/deploy-your-first-smart-contract/deploy-with-foundry) # Deploy with Hardhat This guide will walk you through deploying a counter contract using Hardhat, a popular JavaScript-based development environment for Ethereum. ### Deploying a Counter Contract with Hardhat This guide will walk you through deploying a counter contract using Hardhat, a popular JavaScript-based development environment for Ethereum. ### 1. **Prerequisites** Before you begin, ensure you have: * Node.js installed (v12 or later) * npm (comes with Node.js) * A code editor (e.g., VS Code) * MetaMask wallet and testnet tokens for deployment ### 2. **Install Hardhat** Open your terminal and create a new project directory: ```bash mkdir counter-project cd counter-project ``` Initialize a new npm project: ```bash npm init -y ``` Install Hardhat and required dependencies: ```bash npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox dotenv ``` ```bash npm install --save-dev @nomicfoundation/hardhat-ignition ``` ### 3. **Create a New Hardhat Project** Run the Hardhat setup wizard: ```bash npx hardhat ``` Choose “Create a JavaScript project” when prompted. This will create a project structure like: * `contracts/` - for Solidity contracts * `igntion/` - for deployment scripts * `test/` - for tests * `hardhat.config.js` - configuration file ### 4. **Write Your Smart Contract** Create a new file in the contracts directory, `Counter.sol`: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract Counter { uint256 private count; function increment() public { count += 1; } function decrement() public { count -= 1; } function getCount() public view returns (uint256) { return count; } } ``` ### 5. **Compile the Smart Contract** Compile your contracts with: ```bash npx hardhat compile ``` You should see a success message if there are no errors. ### 6. **Write a Deployment Script** Create a new file in the ignition directory, `Counter.js`: {% code overflow="wrap" %} ```javascript const { buildModule } = require("@nomicfoundation/hardhat-ignition/modules"); module.exports = buildModule("CounterModule", (m) => { const counter = m.contract("Counter"); return { counter }; }); ``` {% endcode %} ### **7. Configure Network Settings** Create a `.env` file in your project root: ``` PRIVATE_KEY=your_private_key_here ``` Edit `hardhat.config.js`: {% code overflow="wrap" %} ```javascript require("@nomicfoundation/hardhat-toolbox"); require("dotenv").config(); module.exports = { solidity: "0.8.28", networks: { hardhat: { chainId: 31337, }, lazai: { url: "https://testnet.lazai.network", chainId: 133718, accounts: [process.env.PRIVATE_KEY], }, }, }; ``` {% endcode %} ### 8**. Deploy Your Contract** **Local Deployment (Optional)** Start the Hardhat local node in a separate terminal: ```bash npx hardhat node ``` Deploy to local network: ```bash npx hardhat ignition deploy ignition/modules/Counter.js --network localhost ``` ### D**eploy to LazAI Testnet** Make sure to: 1. Get testnet tokens from the faucet 2. Add your private key to the `.env` file 3. Never share your private key **Deploy to LazAI:** ``` npx hardhat ignition deploy ignition/modules/Counter.js --network lazai ``` **Test Setup** Create `test/Counter.js`: {% code overflow="wrap" %} ```javascript const { expect } = require("chai"); describe("Counter", function () { it("Should increment the counter", async function () { const Counter = await ethers.getContractFactory("Counter"); const counter = await Counter.deploy(); await counter.deployed(); await counter.increment(); expect(await counter.getCount()).to.equal(1); }); }); ``` {% endcode %} **Running Tests** ```sh npx hardhat test ``` # Deploy with Foundry Deploying a Counter Contract with Foundry This guide will walk you through deploying a counter contract using Foundry, a fast and portable toolkit for Ethereum application development. ### **1. Prerequisites** Before you begin, make sure you have: * A code editor (e.g., VS Code) * MetaMask wallet for deploying to testnets * RPC endpoint for deploying to a network ### 2. **Install Foundry** Open your terminal and run: ```bash curl -L https://foundry.paradigm.xyz | bash ``` This installs foundryup, the Foundry installer. Next, run: ```bash foundryup ``` This will install the Foundry toolchain (forge, cast, anvil, chisel). Check the installation: ```bash forge --version ``` ### 3. **Initialize a New Project** Create a new directory for your project and initialize Foundry: ```bash forge init Countercd Counter ``` This creates a project with the following structure: * `src/` - for your smart contracts * `test/` - for Solidity tests * `script/` - for deployment scripts * `lib/` - for dependencies * `foundry.toml` - project configuration file ### **4. Explore the Counter Contract** Foundry initializes your project with a Counter contract in `src/Counter.sol`: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract Counter { uint256 private count; function increment() public { count += 1; } function decrement() public { count -= 1; } function getCount() public view returns (uint256) { return count; } } ``` This contract stores a number and allows you to set or increment it. ### 5. **Compile the Contract** Compile your smart contracts with: ```bash forge build ``` This command compiles all contracts in `src/` and outputs artifacts to the `out/` directory. ### 6. **Run Tests** Foundry supports writing tests in Solidity (in the `test/` directory). To run all tests: ```bash forge test ``` You’ll see output indicating which tests passed or failed. The default project includes a sample test for the Counter contract. ### **7. Deploying Your Contract** To deploy your contract to the LazAI testnet, you’ll need: * An RPC URL * A private key with testnet LAZAI Example deployment command for LazAI testnet: ```bash forge create --rpc-url https://testnet.lazai.network \ --private-key \ src/Counter.sol:Counter \ --broadcast ``` Replace `` with your actual private key. Never share your private key. ### **8. Interacting with Contracts** You can use cast to interact with deployed contracts, send transactions, or query data. For example, to read the number variable on LazAI testnet: ```bash cast call "number()(uint256)" --rpc-url https://lazai-testnet.metisdevops.link ``` # Deploy with Remix Deploy Smart Contract on LazAI Chain using Remix ### **1. Prerequisites** Before you begin, ensure you have: * A web browser (Chrome, Firefox, or Edge recommended) * MetaMask wallet extension installed * LazAI testnet tokens (get from faucet) ### **2. Setup MetaMask for LazAI Testnet** #### **Add LazAI Network to MetaMask** 1. Open MetaMask extension 2. Click on the network dropdown (usually shows "Ethereum Mainnet") 3. Click "Add Network" 4. Enter the following details: {% content-ref url="/pages/Ot9WMpIPhxBampdkrneM" %} [Broken mention](broken://pages/Ot9WMpIPhxBampdkrneM) {% endcontent-ref %} ### Contract Addresses 1. Click "Save" to add the network 2. Switch to LazAI Testnet in MetaMask #### **Get Testnet Tokens** Visit the LazAI faucet to get Testnet Tokens for deployment and transaction fees. ### **3. Access Remix IDE** 1. Open your web browser 2. Go to 3. Remix IDE will load automatically - no installation required ### **4. Create Your Smart Contract** #### **Create a New File** 1. In the File Explorer (left panel), click the "+" icon next to "contracts" 2. Name your file `Counter.sol` 3. Add the following code: ```solidity // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; contract Counter { uint256 private count; function increment() public { count += 1; } function decrement() public { count -= 1; } function getCount() public view returns (uint256) { return count; } } ``` ### **5. Compile Your Contract** #### **Select Compiler Version** 1. Click on the "Solidity Compiler" tab (second icon in left panel) 2. Select compiler version `0.8.0` or higher 3. Ensure "Auto compile" is checked (optional but recommended) #### **Compile** 1. Click "Compile Counter.sol" button 2. Check for any compilation errors in the console 3. Green checkmark indicates successful compilation ### **6. Deploy Your Contract** #### **Setup Deployment Environment** 1. Click on "Deploy & Run Transactions" tab (third icon in left panel) 2. In the "Environment" dropdown, select "Injected Provider - MetaMask" 3. MetaMask will prompt you to connect - click "Connect" 4. Ensure you're connected to LazAI Testnet in MetaMask #### **Deploy Contract** 1. Under "Contract" dropdown, select "Counter" 2. Click "Deploy" button 3. MetaMask will open asking you to confirm the transaction 4. Review gas fees and click "Confirm" 5. Wait for transaction confirmation # Introduction LazAI is designed to create a fully decentralized AI ecosystem, enabling verifiable AI data, computation, and assetization. To achieve this, the platform follows a modular architecture that ensures seamless interaction between AI models, datasets, developers, and blockchain infrastructure.
The LazAI Platform Architecture consists of the following layers: * **Application Layer:** By combining on-chain verification, decentralized computing, and tokenized AI asset management, the application layer establishes a robust Web3-native AI infrastructure * **Trust and Execution Layer:** Powered by LazChain, this layer serves as the core infrastructure for AI asset issuance, circulation, and computation verification. * **Extension Layer:** Facilitates external data integration, model provider participation, and advanced AI service expansion to enhance interoperability across Web3. # Application Layer The application layer serves as the primary interface for user interaction with the LazAI platform, designed to deliver coamprehensive lifecycle services spanning data processing, AI asset transactions, and management. By leveraging a diverse range of native decentralized applications (DApps) and robust tool integrations, the application layer not only provides advanced technical support for Web3 innovators but also ensures a seamless and user-friendly experience for Web2 participants. This enables developers, consumers, and data providers to efficiently integrate into the LazAI ecosystem, collectivelay driving the adoption and advancement of AI and blockchain technologies. * **Alith - A Privacy-First AI Agent Framework:** Alith is a key functional component and development framework within the LazAI platform, enabling users to create and deploy personalized MicroAgents. * **Agent Launchpad:** The Agent Launchpad enables developers and iDAO communities to create, customize, and launch AI agents as decentralized digital assets. * **DAT Marketplace:** The DAT Marketplace is LazAI’s primary trading and verification hub for AI assets, including datasets, AI models, and AI agents. * **DeFAI:** The DeFAI module combines LazAI’s advanced AI technology with Web3’s decentralized finance (DeFi) capabilities to deliver innovative financial services. Let's deep dive into each core component of application layer. # DAT Marketplace - Coming soon The DAT Marketplace is LazAI’s primary trading and verification hub for AI assets, including datasets, AI models, and AI agents. It ensures that AI-generated content, training data, and computational proofs are transparently exchanged under verifiable conditions. #### Key Features: * **DAT-Powered AI Assetization:** All AI datasets, models, and agents are anchored as DAT tokens, ensuring ownership verification and seamless exchange. * **Decentralized Verification:** Built-in on-chain proof mechanisms (ZK Proofs & Optimistic Proofs) validate AI asset integrity before transactions. * **Dynamic Licensing & Access Control:** Enables programmatic AI data licensing, including API-based pay-per-use, long-term access licenses & subscriptions, and collaborative model training. * **AI Resource Discovery:** Uses machine learning-based search and recommendation algorithms to enhance AI asset discoverability. The DAT Marketplace redefines AI development and collaboration, eliminating data silos while enabling trustless AI monetization. # DeFAI: AI-Driven DeFi - Coming Soon The DeFAI module combines LazAI’s advanced AI technology with Web3’s decentralized finance (DeFi) capabilities to deliver innovative financial services. By integrating AI assets such as datasets, models, and agents with blockchain technology, DeFAI creates a multi-dimensional financial ecosystem. #### Key Features: * **Decentralized Asset Library:** Users can register datasets, models, and agents as tradable digital assets via distributed storage, creating a dynamically growing AI asset marketplace. * **On-Chain Financial Derivatives:** Leveraging DeFi mechanisms, DeFAI supports financial operations such as staking, lending, and revenue distribution based on AI assets. It also encourages community-driven financial innovation through iDAO initiatives. * **Smart Contract Integration:** Seamless interaction between on-chain and off-chain resources is enabled through smart contracts, ensuring transparency and security in all financial operations. * **AI Dataset Staking & Liquidity Pools:** Users can stake AI datasets or models as collateral to earn rewards. * **AI-Driven Risk Analysis:** Uses AI algorithms for credit scoring, fraud detection, and predictive market insights. * **AI Model Bonds & Derivatives:** Enables the issuance of financial instruments based on AI model revenue generation. DeFAI not only opens additional monetization channels for developers but also helps users unlock the latent value of AI assets through financial innovation. # Extention Layer The Extension Layer serves as the foundation for expanding LazAI’s capabilities, enabling seamless integration with both on-chain and off-chain resources. This layer is designed to enhance verifiable computing, expand data and model accessibility, and improve real-time AI execution, ensuring that LazAI remains at the forefront of decentralized AI innovation. ### Expanding the Verified Computing Framework A core requirement of decentralized AI applications is trustless, verifiable computation. LazAI enhances its Verified Computing Framework by integrating cutting-edge cryptographic techniques and secure computing environments: * **TEE (Trusted Execution Environments):** Enables hardware-backed confidential computing, ensuring that AI models and computations remain secure while still being verifiable. * **ZK Provers (Zero-Knowledge Proofs):** Enhances privacy-preserving validation by allowing AI inference and dataset computations to be verified without revealing raw data. * **Hybrid Verification Models:** Combines Optimistic Proofs (OP) for efficiency and Fraud Proofs for dispute resolution, balancing performance and security in decentralized AI validation. By continuously adopting state-of-the-art verification techniques, LazAI ensures secure, scalable, and transparent AI execution across decentralized infrastructures. ### Data Providers & Decentralized Data Governance AI applications require high-quality, multi-dimensional datasets to function optimally. The Extension Layer facilitates scalable, trustless data provisioning by incorporating multiple data sources while maintaining robust privacy and governance mechanisms. By expanding the LazAI ecosystem with diverse data providers, the Extension Layer empowers AI models with high-quality, verifiable, and privacy-respecting datasets. ### Expanding Model Providers LazAI is designed to be model-agnostic, supporting multiple AI model providers beyond Alith. This ensures that developers can freely innovate, optimize, and integrate their AI solutions while benefiting from LazAI’s decentralized AI infrastructure. **Key Model Expansion Strategies:** * **Multi-Framework Compatibility:** Support for more mainstream and custom models ensures interoperability with leading AI tools. * **Custom Model Optimization:** On-chain quantization & pruning techniques to improve performance while minimizing gas costs. By fostering a rich ecosystem of AI models, the expanding model providers ensure that LazAI remains highly flexible, scalable, and future-proof. ### Enhanced Oracle Services for DeFAI & Real-Time Adaptability LazAI is designed to be responsive to real-world changes, requiring highly efficient and dynamic oracle services. The Extension Layer expands DeFAI (Decentralized AI Finance) functionalities by integrating diverse, high-frequency oracle data streams. **Key Oracle Enhancements:** * **Multi-Dimensional Oracle Feeds:** * On-Chain Token Price Oracles for dynamic AI-driven DeFi strategies. * Real-Time Market & Economic Data from decentralized news sources. * AI-Driven Sentiment Analysis Oracles to assess social & financial trends. * **Cross-Layer Data Flow:** * Integration with Web3 Data Aggregators (The Graph, Chainlink, Pyth). * On-Chain Event Triggers enabling AI-based decision-making in DeFi, Governance, and DAOs. By introducing real-time oracles, LazAI ensures that AI-driven applications can rapidly adapt to dynamic market, social, and economic conditions.
# Overview The Data Anchoring Token (DAT) is the foundational standard of the LazAI and Alith ecosystems. It enables contributors to share privacy-sensitive datasets, AI models, or computation results while retaining full ownership, control, and economic rights. DATs act as on-chain certificates of contribution, linking data provenance, access permissions, and value distribution directly to blockchain-based records. *** ### Key Capabilities Each DAT encodes three primary dimensions of data ownership and utility: | Capability | Description | | --------------------- | ----------------------------------------------------------------------------------------------------------------- | | Ownership Certificate | Records verifiable proof of contribution or authorship for datasets, models, or computation results. | | Usage Rights | Defines how and where the data can be accessed — for example, by AI services, model training, or agent execution. | | Value Share | Assigns proportional economic rewards to contributors based on usage, staking, or licensing activity. | *** ### Why AI Needs a New Token Standard AI data is dynamic, composable, and frequently reused across models and tasks — properties that traditional token standards like ERC-20 and ERC-721 don’t fully support. DAT introduces a semi-fungible token (SFT) model designed for modularity, traceability, and partial ownership of AI assets. #### Comparison Summary | Token Type | Description | Limitation | | ---------------------- | ---------------------------------------------------------------------------------------- | ------------------------------------------------------- | | ERC-20 (Fungible) | Fully interchangeable tokens, ideal for currency or credits. | Cannot represent unique datasets or ownership records. | | ERC-721 (Non-Fungible) | Unique tokens for singular assets (e.g., one-of-a-kind NFTs). | Lacks divisibility and modularity for AI workloads. | | DAT (Semi-Fungible) | Hybrid model combining ERC-20 and ERC-721 traits — divisible, composable, and traceable. | Tailored for data provenance and AI-specific workflows. | *** ### How DAT Works 1. Data Contribution: A user encrypts and uploads a dataset or model output through LazAI’s privacy framework. 2. Metadata Anchoring: A smart contract logs encrypted metadata, provenance proofs, and ownership claims on-chain. 3. Verification: Validators or trusted enclaves (TEE) confirm authenticity and compliance. 4. Tokenization: A DAT is minted as a semi-fungible token representing the data’s rights, access rules, and value distribution. *** ### Technical Highlights * Standard: Semi-Fungible Token (SFT) * Purpose: Tokenize AI datasets, models, and computation outputs * Blockchain Layer: LazAI Testnet (EVM-compatible) * Supports: On-chain provenance, privacy-preserving validation, and composable ownership logic *** ### Benefits | Benefit | Description | | --------------------- | -------------------------------------------------------------------------------- | | Verifiable Provenance | Every dataset or model is cryptographically tied to its origin and contributor. | | Data Monetization | Contributors can receive automatic rewards or royalties for approved AI usage. | | Privacy by Design | Encryption and TEE validation ensure that raw data remains confidential. | | Composable Ownership | DATs can be merged, split, or referenced across multiple models or applications. | *** ### Related Concepts * DAT Architecture →![Attachment.tiff](file:///Attachment.tiff) * Lifecycle & Value Semantics →![Attachment.tiff](file:///Attachment.tiff) * Contribute Your Data →![Attachment.tiff](file:///Attachment.tiff) # Concepts & Architecture The Data Anchoring Token (DAT) framework defines how AI-native digital assets are represented, verified, and monetized on the LazAI Network. It provides the foundational logic for data ownership, usage rights, and value attribution, using an interoperable, on-chain token standard. This section explores the design principles, technical architecture, and lifecycle that power the DAT ecosystem. *** ### Overview At its core, the DAT standard bridges AI data provenance with decentralized economic infrastructure. It ensures that every dataset, model, or computational artifact is: * Verifiable — its origin, authenticity, and contribution are cryptographically recorded. * Usable — its access rights are programmable and enforceable via smart contracts. * Rewardable — contributors automatically receive fair value for downstream AI usage. By combining these three properties, LazAI establishes a new foundation for a transparent and composable AI economy. *** ### Architecture Summary The DAT system is built on five interoperable layers: | Layer | Description | | ------------------------------- | -------------------------------------------------------------------------------- | | 1. Encryption & Data Layer | Encrypts contributed data and anchors its proof of existence. | | 2. Metadata & Provenance Layer | Records dataset or model attributes, versioning, and authorship on-chain. | | 3. Smart Contract Layer | Governs DAT minting, validation, transfers, and settlement logic. | | 4. Verification Layer (TEE/ZK) | Verifies authenticity through trusted execution or zero-knowledge proofs. | | 5. Tokenization & Economy Layer | Issues semi-fungible DATs that encode ownership, usage, and value participation. | 📘 Learn more: View the Architecture →![Attachment.tiff](file:///Attachment.tiff) *** ### Lifecycle Overview DATs follow a transparent and programmable lifecycle: 1. Create Class — Define an AI asset category (dataset, model, or agent). 2. Contribute Data — Upload and encrypt data, storing metadata in decentralized storage. 3. Mint DAT — Bind ownership and usage rights to a token. 4. Invoke Service — Use DATs to access or call AI services. 5. Distribute Rewards — Automatically split revenue based on shareRatio. 6. Expire or Renew — Handle time-bound access or licensing renewal. 📘 Learn more: See Lifecycle & Value Semantics →![Attachment.tiff](file:///Attachment.tiff) *** ### Security & Privacy Principles The DAT standard integrates privacy-preserving computation and cryptographic guarantees to protect sensitive AI data. | Security Component | Description | | --------------------------- | ------------------------------------------------------------------------------- | | Encryption at Source | Data is encrypted locally before upload using hybrid AES–RSA keys. | | TEE Verification | Trusted enclaves validate computation integrity without exposing raw data. | | Zero-Knowledge Proofs (ZKP) | Optional layer for verifying claims or usage without revealing private details. | | Access Control Policies | Enforced on-chain to prevent unauthorized dataset or model invocation. | 📘 Learn more: Explore Security & Privacy Model →![Attachment.tiff](file:///Attachment.tiff) *** ### Design Highlights | Feature | Description | | --------------------------- | ------------------------------------------------------------------ | | Composable Data Assets | Combine or split data ownership across classes and users. | | Royalty-Backed Tokenization | Link AI model or dataset revenue directly to token holders. | | Programmable Usage Rights | Define dynamic access rules, quotas, or billing models. | | Interoperable with EVM | Fully compatible with standard Ethereum tools and smart contracts. | *** ### Developer Roadmap
StepAction
1Learn the DAT Architecture →Attachment.tiff
2Understand Lifecycle & Value Semantics →Attachment.tiff
3Review Security & Privacy Model →Attachment.tiff
4Implement your first DAT using the Developer Implementation Guide →Attachment.tiff
*** #### Summary The Concepts & Architecture layer provides developers with a clear understanding of how DAT integrates cryptography, smart contracts, and token economics to create a verifiable and monetizable AI data framework. Together, these concepts enable a scalable foundation for the decentralized AI economy built on LazAI. # Architecture The Data Anchoring Token (DAT) architecture defines the core technical stack that powers verifiable AI data ownership on the LazAI Network. It provides a layered framework where data, metadata, and economic value interact securely through smart contracts and cryptographic proofs. ### 1. System Overview At a high level, the DAT framework connects contributors, AI agents, and the blockchain using a multi-layered architecture: ``` graph TD A[Contributor / AI Developer] --> B[Encryption & Data Layer] B --> C[Metadata & Provenance Layer] C --> D[Smart Contract Layer] D --> E[Verification Layer (TEE / ZKP)] E --> F[Tokenization & Economy Layer] F --> G[DAT Holder / Service Consumer] ``` This structure ensures every contributed dataset, model, or inference is: * Encrypted and verifiable * Anchored to an immutable provenance record * Represented as a semi-fungible DAT token * Linked to programmable usage and revenue logic ### 2. Layered Components #### 2.1 Encryption & Data Layer * Encrypts raw data locally before submission using hybrid AES + RSA. * Generates a unique data fingerprint (SHA-256 hash) for integrity tracking. * Stores encrypted payloads in decentralized archives (IPFS, Filecoin, or private storage). Output: Encrypted file + integrity hash #### 2.2 Metadata & Provenance Layer * Records asset identity, class, description, and URI in a metadata schema. * Maintains the provenance of contribution (creator, timestamp, ownership chain). * Anchors metadata hashes to the blockchain for tamper-proof traceability. Output: Immutable metadata anchor #### 2.3 Smart Contract Layer * Core on-chain logic that manages the DAT lifecycle: * Registering data contributions * Minting and binding tokens to assets * Managing value transfers and ownership rights * Enables composable operations like: * registerData(), mintDAT(), transferValue(), claimRewards() Output: On-chain record of ownership, value, and access #### 2.4 Verification Layer * Validates submitted data through Trusted Execution Environments (TEE) or Zero-Knowledge Proofs (ZKPs). * Ensures the computation or dataset matches the registered proof without revealing the raw data. * Provides verifiable attestations used for DAT minting authorization. Output: Signed proof of authenticity #### 2.5 Tokenization & Economy Layer * Issues a semi-fungible DAT token (SFT) representing the verified contribution. * Encodes three properties: * Ownership Certificate * Usage Rights (e.g., call credits, model usage) * Value Share (fractional rewards) * Integrates with payment and settlement contracts to automate royalty flow. Output: Minted DAT with on-chain economic logic ### 3. Data Flow Summary ``` 1. Encrypt data → Generate hash 2. Upload to decentralized archive 3. Register metadata and hash on-chain 4. Validate via TEE or ZKP 5. Mint DAT token representing the asset 6. Use DAT to access AI services or earn rewards ``` ### 4. Smart Contract Structure | Function | Description | | -------------------------------------------------- | --------------------------------------------------------------- | | createClass(name, uri) | Defines a new class of AI assets (datasets, models, or agents). | | mintDAT(owner, classId, value, shareRatio, expiry) | Issues a token for a verified contribution. | | transferValue(fromToken, toToken, amount) | Enables fine-grained value or credit transfer. | | claimRewards(classId) | Distributes on-chain rewards proportionally. | | verifyData(hash, proof) | Validates integrity through off-chain verifier. | ### 5. Integration Points | Integration | Description | | -------------------- | ------------------------------------------------------------ | | TEE Verifiers | Used for confidential validation without exposing data. | | AI Agents / Oracles | Consume DATs as compute or model credits. | | External Data Feeds | Can be integrated via API or SDK for automated registration. | | Wallets & Dashboards | Manage minting, ownership, and analytics visually. | ### 6. Design Principles | Principle | Description | | ---------------- | --------------------------------------------------------- | | Privacy First | No unencrypted data leaves the contributor’s device. | | Interoperability | Fully EVM-compatible and modular for AI agent extensions. | | Composability | DATs can be split, merged, or reused across workflows. | | Transparency | Each operation emits verifiable on-chain events. | ### 7. Developer Navigation * 🔹 Lifecycle & Value Semantics →![Attachment.tiff](file:///Attachment.tiff) Learn how DATs evolve from registration to value realization. * 🔹 Security & Privacy Model →![Attachment.tiff](file:///Attachment.tiff) Explore how encryption, TEE, and ZKP ensure data safety. * 🔹 Developer Implementation →![Attachment.tiff](file:///Attachment.tiff) Start building and minting your first DAT. # DAT Specification ### Core Structure
FieldDescription
IDEach DAT is a unique token representing a specific AI asset
CLASSCategory of asset (e.g., POV, Model, Inference)
VALUERepresents usage quota or revenue share
PROOFAttached proof for authenticity (e.g., ZK, TEE, OP)
### Sample Metadata Schema `{` `"name": "Timi + Fine-Tuned Llama Model v2",` `"class": "0x03",` `"value": 2500,` `"proof": {` `"type": "ZK-SNARK",` `"hash": "0xabc123...",` `"verifiedBy": "0xVerifierContract"` `},` `"usagePolicy": {` `"maxCalls": 1000,` `"expiresAt": "2026-12-31"` `},` `"revenueShare": {` `"totalShares": 10000,` `"holderShare": 2500` `},` `"rights": {` `"license": "commercial_use_allowed",` `"canTransfer": true` `}` `}` # DAT Lifecycle Example
#### Step 1: Create Class (AI Asset Category) `createClass(` `1,` `"Medical Dataset",` `"Open-source dataset for disease classification",` `"ipfs://metadata/med-dataset-class"` `)` #### Step 2: Mint DAT Token (Bind & Issue Asset) `mintDAT(` `user1,` `1,` // classId: Medical Dataset `1000 * 1e6,` // value: 1000 (6 decimals) `500,` // shareRatio: 5% `0` // expireAt: never expires `);` 💡 **Option:** Mint multiple DATs to simulate multi-user ownership #### Step 3: Service Payment (Agent Invocation) `transferValue(user1TokenId, agentTreasuryTokenId, 100 * 1e6);` * `agentTreasuryTokenId` may be a treasury contract address * Supports “pay-as-you-use” or delegated billing models #### Step 4: Revenue Share Demonstration (Future Extension) Assume an agent earns 10 USDC: `agent.payToDATHolders(classId, 10 USDC);` * Contract calculates each DAT’s shareRatio * Distributes revenue proportionally #### Step 5: Token Expiration (Optional) `require(block.timestamp < dats[tokenId].expireAt, "Token expired");` Used for subscription-based AI services or time-bound licenses # Value Semantics Service Usage + Revenue Share #### 1. Service Usage (Agent Call Credit) Every DAT token includes a value field representing service credit. It can be used to: * Call Alith Agents * Pay for dataset/model usage * Be consumed per use, recharged, or reused **Example:** A DAT with CLASS = 0x03 and value = 1000 allows 1000 calls to a model or equivalent compute. Extensions: * Value can be recharged * Value is deducted upon use and recorded on-chain for traceability #### 2. Revenue Share (Fractional Ownership) In dataset or model-based DATs, value also indicates fractional ownership, allowing holders to earn revenue share: * If a model is used by other agents, income is split proportionally * If a dataset is used for training, contributors earn a share * Rewards are automatically settled to token holders — no manual claim needed **Example:** * Model DAT #1234 has 10,000 total shares * You hold a token with value = 500 * If the model earns 10,000 DAT in a month, you receive:\ 500 / 10,000 × 10,000 = 500 DAT # Developer Implementation This section shows how to build and integrate with the LazAI Network using the Data Anchoring Token (DAT). It covers how developers can upload data, mint tokens, verify proofs, and track their assets on-chain. *** ### What You’ll Learn The Developer Implementation guides help you: 1. Contribute your data or model to the LazAI network. 2. Mint your DAT — a token that represents ownership, access rights, and value share. 3. Verify proofs on-chain to confirm authenticity. 4. Manage your DATs using the LazAI Dashboard. *** ### How It Works The implementation flow connects your data pipeline to LazAI’s verified network: | Step | Description | | ------------- | -------------------------------------------------------------- | | 1. Contribute | Upload encrypted datasets or models to IPFS. | | 2. Mint | Register and issue your DAT token using the Alith SDK. | | 3. Verify | Generate and validate proofs through verified computing nodes. | | 4. Monitor | View all DATs and rewards in the dashboard. | *** ### Tools You’ll Use * Alith SDK (Python) – for data upload, proof, and token minting. * IPFS – decentralized file storage. * DAT Smart Contracts – manage ownership and usage rights. * Dashboard UI – monitor token activity and rewards. *** ### Next Steps Start with the following guides: * [Contribute Your Dat](/data-anchoring-token-dat/developer-implementation/contribute-your-data) * [Mint Your DAT](/data-anchoring-token-dat/developer-implementation/mint-your-dat) * [Verify DAT On-Chain](/data-anchoring-token-dat/developer-implementation/verify-dat-on-chain) *** Would you like me to now write the Contribute Your Data page in the same clear, short, and professional format (so it connects smoothly to this one)? # Contribute Your Data LazAI enables data contributors to securely share privacy-sensitive data, computation, and resources, earning rewards while retaining full control over their data. This section will guide you through.Each DAT serves as a transparent certificate on the blockchain: you can trace exactly where the data came from, how it has been used, and who has rights to it.LazAI leverages OpenPGP encryption to secure privacy data. The encryption workflow is as follows: * A random symmetric key is generated to encrypt the data using a symmetric encryption algorithm (e.g., AES). * This symmetric key is then encrypted with the recipient’s public key via an asymmetric encryption algorithm (RSA), producing the final encrypted payload. **Workflow Steps:** 1. A random key is derived from the user’s Web3 wallet (e.g., MetaMask) and used as a password to encrypt the user’s private data. This step authenticates the sender’s identity. 2. The encrypted symmetric key (via RSA) and the encrypted data are uploaded to a decentralized archive (DA) (e.g., IPFS, Google Drive, or Dropbox). 3. The encrypted data’s URL and the encrypted key are registered on the LazAI smart contract. 4. A test data verifier decrypts the symmetric key using their private key, downloads the encrypted data via the URL, and decrypts it within a trusted execution environment (TEE) to ensure security. 5. The decrypted data and a TEE-generated proof are uploaded to the LazAI contract for validation. 6. Upon successful verification, users can submit a request via LazAI to receive Data Anchor Tokens (DAT) as rewards. # Mint your DAT This page walks you through minting a Data Anchor Token (DAT) on the LazAI Pre-Testnet using one of our SDKs: Node.js, Python, or Rust. ### About Data Contribution LazAI enables contributors to securely share privacy-sensitive data, computation, and resources while earning rewards — all without surrendering ownership or control over their data.Data contribution is the cornerstone of the LazAI and Alith ecosystems. Contributors decide exactly how their data can be used (e.g., on-chain training, inference, evaluation) and also gain governance rights. ### How LazAI protects your data LazAI uses strong encryption to ensure that only authorized parties can access your data: 1. Symmetric encryption — A random symmetric key (e.g., AES) is generated to encrypt your data. 2. Asymmetric encryption — The symmetric key is then encrypted with the recipient’s public key using RSA. 3. The final payload (encrypted data + encrypted key) is stored securely in decentralized storage. ### End-to-end contribution flow 1. Key derivation — A random key is derived from your Web3 wallet (e.g., MetaMask) and used to encrypt your private data, proving sender authenticity. 2. Storage — The encrypted symmetric key and encrypted data are uploaded to a Decentralized Archive (DA) such as IPFS, Google Drive, or Dropbox. 3. On-chain registration — The storage URL and encrypted key are registered in LazAI’s smart contracts. 4. Verification — A designated verifier decrypts the symmetric key with their private key, retrieves the data, and decrypts it inside a Trusted Execution Environment (TEE). 5. Proof & validation — The TEE generates a proof that is uploaded to LazAI for contract-level validation. 6. Rewards — Upon successful verification, contributors receive Data Anchor Tokens (DAT). # Mint your DAT in Python This guide walks through the process of setting up your local environment, connecting your wallet, and minting your first Data Anchoring Token (DAT) using the LazAI Python SDK. It assumes familiarity with Python, basic blockchain interactions, and access to the LazAI Pre-Testnet.\ \ For a guided walkthrough of the entire setup and minting process, watch the official tutorial:\ ➡️ *** ### Prerequisites Ensure the following tools and credentials are available before starting: | Requirement | Description | | ----------- | ------------------------------------------------------------------------------------------------------------- | | Python | Version 3.10 or later | | pip | Latest package manager version | | Wallet | Funded Pre-Testnet wallet for gas fees | | Credentials | PRIVATE\_KEY — your wallet private key (must start with 0x) IPFS\_JWT — Pinata (or compatible) IPFS JWT token | *** ### Step 1. Project Setup Create a new working directory and (optionally) set up a virtual environment. ```bash mkdir lazai-contribution-py cd lazai-contribution-py # Optional: create a Python virtual environment python3 -m venv .venv source .venv/bin/activate # Windows: .venv\Scripts\activate ``` *** ### Step 2. Install Dependencies Install the LazAI SDK and required libraries. ```bash python3 -m pip install -U alith requests rsa eth-account ``` If you prefer to load environment variables from a .env file instead of exporting them directly, install: ```bash python3 -m pip install python-dotenv ``` *** ### Step 3. Configure Environment Variables Set your credentials in the shell environment: ```bash export PRIVATE_KEY= # must start with 0x export IPFS_JWT= ``` If you are using a .env file, include: ```bash from dotenv import load_dotenv load_dotenv() ``` at the top of your Python script. *** ### Step 4. Create the Minting Script Create a file named mint.py and paste the following code. ```python from alith.lazai import Client, ProofRequest from alith.data import encrypt from alith.data.storage import ( PinataIPFS, UploadOptions, GetShareLinkOptions, StorageError, ) from eth_account.messages import encode_defunct from os import getenv import asyncio import requests import rsa import aiohttp from pydantic import BaseModel from typing import Optional class ActualPinataUploadResponse(BaseModel): id: str name: str cid: str size: int number_of_files: int mime_type: str created_at: str updated_at: str network: str streamable: bool accept_duplicates: Optional[bool] = None is_duplicate: Optional[bool] = None group_id: Optional[str] = None class CustomPinataIPFS(PinataIPFS): async def upload(self, opts: UploadOptions): url = "https://uploads.pinata.cloud/v3/files" form = aiohttp.FormData() form.add_field("file", opts.data, filename=opts.name, content_type="text/plain") form.add_field("network", "public") headers = {"Authorization": f"Bearer {opts.token}"} try: async with self.client.post(url, data=form, headers=headers) as response: if response.status != 200: error_text = await response.text() raise StorageError(f"Pinata IPFS API error: {error_text}") data = await response.json() pinata_response = ActualPinataUploadResponse(**data["data"]) from alith.data.storage import FileMetadata return FileMetadata( id=pinata_response.cid, name=pinata_response.name, size=pinata_response.size, modified_time=pinata_response.updated_at, ) except aiohttp.ClientError as e: raise StorageError(f"Network error: {str(e)}") from e async def main(): client = Client() ipfs = CustomPinataIPFS() try: # 1. Prepare and encrypt data data_file_name = "your_encrypted_data.txt" privacy_data = "Your Privacy Data" encryption_seed = "Sign to retrieve your encryption key" message = encode_defunct(text=encryption_seed) password = client.wallet.sign_message(message).signature.hex() encrypted_data = encrypt(privacy_data.encode(), password) # 2. Upload to IPFS token = getenv("IPFS_JWT", "") file_meta = await ipfs.upload( UploadOptions(name=data_file_name, data=encrypted_data, token=token) ) url = await ipfs.get_share_link(GetShareLinkOptions(token=token, id=file_meta.id)) # 3. Register file on LazAI file_id = client.get_file_id_by_url(url) if file_id == 0: file_id = client.add_file(url) # 4. Request proof from verified node client.request_proof(file_id, 100) job_id = client.file_job_ids(file_id)[-1] job = client.get_job(job_id) node_info = client.get_node(job[-1]) node_url: str = node_info[1] pub_key = node_info[-1] encryption_key = rsa.encrypt( password.encode(), rsa.PublicKey.load_pkcs1(pub_key.strip().encode(), format="PEM"), ).hex() response = requests.post( f"{node_url}/proof", json=ProofRequest( job_id=job_id, file_id=file_id, file_url=url, encryption_key=encryption_key, encryption_seed=encryption_seed, proof_url=None, ).model_dump(), ) if response.status_code == 200: print("Proof request sent successfully.") else: print("Failed to send proof request:", response.json()) # 5. Request DAT reward client.request_reward(file_id) print("Reward requested for file id", file_id) except StorageError as e: print(f"Storage error: {e}") except Exception as e: raise e finally: await ipfs.close() if __name__ == "__main__": asyncio.run(main()) ``` *** ### Step 5. Run the Script Execute the minting process. ```bash python mint.py ``` Expected Output: ```bash Proof request sent successfully Reward requested for file id ``` *** ### Troubleshooting | Issue | Cause | Resolution | | ------------------------------ | ---------------------------------------- | ------------------------------------------------------------------- | | eth\_keys or signing errors | Invalid private key format | Ensure PRIVATE\_KEY starts with 0x and Python version ≥ 3.10 | | 401 / 403 IPFS errors | Invalid or expired JWT | Verify your IPFS\_JWT and permissions in Pinata | | Request or connection failures | Node busy or network timeout | Wait a minute and retry; confirm your Pre-Testnet RPC configuration | | StorageError | Invalid token or transient network issue | Retry the upload or reinitialize IPFS connection | *** ### Summary This tutorial demonstrated how to: 1. Set up a local LazAI development environment. 2. Encrypt and upload data to IPFS. 3. Register and anchor it on the LazAI Network. 4. Generate verifiable proof and mint a DAT. 5. Request tokenized rewards on-chain. Once this is running successfully, you can integrate the same workflow into your agent or service pipeline using the Alith SDK for automated data anchoring and reward management. # Mint your DAT in Node.JS This guide walks through the process of setting up your local environment, connecting your wallet, and minting your first Data Anchoring Token (DAT) using the LazAI Node.JS SDK. It assumes familiarity with Node.JS, basic blockchain interactions, and access to the LazAI Pre-Testnet.\ \ For a guided walkthrough of the entire setup and minting process, watch the official tutorial:\ ➡️ \ \ Prerequisites * Node.js ≥ 18.x (LTS) * A funded Testnet wallet (for gas) * Credentials: * PRIVATE\_KEY – your wallet’s private key (starts with 0x) * IPFS\_JWT – Pinata (or compatible) IPFS JWT ### 1) Project setup ``` mkdir LazAI-contribution cd LazAI-contribution npm init -y ``` ### 2) Install SDK & dependencies ``` npm install alith@latest axios dotenv node-rsa ts-node typescript npm install --save-dev @types/node-rsa ``` > dotenv loads env vars, axios sends the proof request, node-rsa encrypts the symmetric key for the verifier. ### 3) Create files ### index.ts Create a file index.ts and paste: ```javascript import { config } from 'dotenv' import { Client } from 'alith/lazai' import { PinataIPFS } from 'alith/data/storage' import { encrypt } from 'alith/data' import NodeRSA from 'node-rsa' import axios from 'axios' import { promises as fs } from 'fs' // Load environment variables config() async function main() { try { // Check for required environment variables const privateKey = process.env.PRIVATE_KEY const ipfsJwt = process.env.IPFS_JWT if (!privateKey) { throw new Error('PRIVATE_KEY environment variable is required') } if (!ipfsJwt) { console.warn('Warning: IPFS_JWT environment variable not set. IPFS operations may fail.') } // Initialize client with private key as third parameter const client = new Client(undefined, undefined, privateKey) const ipfs = new PinataIPFS() console.log('✅ Client initialized successfully') console.log('✅ IPFS client initialized successfully') // 1. Prepare your privacy data and encrypt it const dataFileName = 'your_encrypted_data.txt' const privacyData = 'Your Privacy Data' const encryptionSeed = 'Sign to retrieve your encryption key' const password = client.getWallet().sign(encryptionSeed).signature const encryptedData = await encrypt(Uint8Array.from(privacyData), password) console.log('✅ Data encrypted successfully') // 2. Upload the privacy data to IPFS and get the shared url const fileMeta = await ipfs.upload({ name: dataFileName, data: Buffer.from(encryptedData), token: ipfsJwt || '', }) const url = await ipfs.getShareLink({ token: ipfsJwt || '', id: fileMeta.id }) console.log('✅ File uploaded to IPFS:', url) // 3. Upload the privacy url to LazAI let fileId = await client.getFileIdByUrl(url) if (fileId == BigInt(0)) { fileId = await client.addFile(url) } console.log('✅ File registered with LazAI, file ID:', fileId.toString()) // 4. Request proof in the verified computing node await client.requestProof(fileId, BigInt(100)) const jobIds = await client.fileJobIds(fileId) const jobId = jobIds[jobIds.length - 1] const job = await client.getJob(jobId) const nodeInfo = await client.getNode(job.nodeAddress) const nodeUrl = nodeInfo.url const pubKey = nodeInfo.publicKey const rsa = new NodeRSA(pubKey, 'pkcs1-public-pem') const encryptedKey = rsa.encrypt(password, 'hex') const proofRequest = { job_id: Number(jobId), file_id: Number(fileId), file_url: url, encryption_key: encryptedKey, encryption_seed: encryptionSeed, nonce: null, proof_url: null, } console.log('✅ Proof request prepared') // Write proof request to file await fs.writeFile('proof_request.json', JSON.stringify(proofRequest, null, 2)) console.log('✅ Proof request saved to proof_request.json') const response = await axios.post(`${nodeUrl}/proof`, proofRequest, { headers: { 'Content-Type': 'application/json' }, }) if (response.status === 200) { console.log('✅ Proof request sent successfully') } else { console.log('❌ Failed to send proof request:', response.data) } // 5. Request DAT reward await client.requestReward(fileId) console.log('✅ Reward requested for file id', fileId.toString()) console.log('All operations completed successfully!') } catch (error) { console.error('❌ Error in main function:', error) process.exit(1) } } // Execute the main function main().catch((error) => { console.error('❌ Unhandled error:', error) process.exit(1) }) ``` ### 4) Add tsconfig.json Create tsconfig.json: ```json { "compilerOptions": { "target": "ES2022", "module": "Node16", "moduleResolution": "node16", "strict": true, "esModuleInterop": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "outDir": "./dist", "allowJs": true, "resolveJsonModule": true, "allowSyntheticDefaultImports": true, "experimentalDecorators": true, "emitDecoratorMetadata": true }, "ts-node": { "esm": true, "experimentalSpecifierResolution": "node" }, "include": ["*.ts"], "exclude": ["node_modules"] } ``` ### 5) Set environment variables Create a .env (recommended) or export in your shell: ``` # .env PRIVATE_KEY= IPFS_JWT= ``` > Your PRIVATE\_KEY must start with 0x. > The script reads these via dotenv. ### 6) Run ``` node --loader ts-node/esm index.ts ``` #### Expected output ``` ✅ Client initialized successfully ✅ IPFS client initialized successfully ✅ Data encrypted successfully ✅ File uploaded to IPFS: https://... ✅ File registered with LazAI, file ID: ✅ Proof request prepared ✅ Proof request saved to proof_request.json ✅ Proof request sent successfully ✅ Reward requested for file id All operations completed successfully! ``` # Mint your DAT in RUST This guide walks through the process of setting up your local environment, connecting your wallet, and minting your first Data Anchoring Token (DAT) using the LazAI Rust SDK. It assumes familiarity with Rust, basic blockchain interactions, and access to the LazAI Pre-Testnet.\ \ For a guided walkthrough of the entire setup and minting process, watch the official tutorial:\ ➡️ ## Dependencies ```rust cargo init --bin lazai-dat-rust cd lazai-dat-rust # Alith (from GitHub) with needed features cargo add alith --git https://github.com/0xLazAI/alith --features "lazai,wallet,crypto,ipfs" # Runtime & utils cargo add tokio --features full cargo add reqwest --features json cargo add anyhow cargo add hex cargo add rand_08 ``` ### Env vars 
export PRIVATE_KEY=<your wallet private key>   # must start with 0x
export IPFS_JWT=<your pinata ipfs jwt>
### src/main.rs ```rust use anyhow::Result; use reqwest; use rand_08::thread_rng; use alith::data::crypto::{encrypt, DecodeRsaPublicKey, Pkcs1v15Encrypt, RsaPublicKey}; use alith::data::storage::{DataStorage, PinataIPFS, UploadOptions}; use alith::lazai::{Client, ProofRequest, U256}; #[tokio::main] async fn main() -> Result<()> { // PRIVATE_KEY is read by the wallet inside Client::new_default() let client = Client::new_default()?; let ipfs = PinataIPFS::default(); // 1) Prepare privacy data and encrypt it let data_file_name = "your_encrypted_data.txt"; let privacy_data = "Your Privacy Data"; let encryption_seed = "Sign to retrieve your encryption key"; // Sign the seed to derive a password let password = client .wallet .sign_message_hex(encryption_seed.as_bytes()) .await?; let encrypted_data = encrypt(privacy_data, password.clone())?; // 2) Upload encrypted data to IPFS and get a share link let token = std::env::var("IPFS_JWT")?; let file_meta = ipfs .upload( UploadOptions::builder() .name(data_file_name.to_string()) .data(encrypted_data) .token(token.clone()) .build(), ) .await?; let url = ipfs.get_share_link(token, file_meta.id).await?; // 3) Register the URL on LazAI let mut file_id = client.get_file_id_by_url(url.as_str()).await?; if file_id.is_zero() { file_id = client.add_file(url.as_str()).await?; } // 4) Request a proof from a verified computing node client.request_proof(file_id, U256::from(100)).await?; let job_id = client.file_job_ids(file_id).await?.last().cloned().unwrap(); let job = client.get_job(job_id).await?; let node_info = client.get_node(job.nodeAddress).await?.unwrap(); let node_url = node_info.url; let pub_key_pem = node_info.publicKey; // Encrypt the password with the node's RSA public key let pub_key = RsaPublicKey::from_pkcs1_pem(&pub_key_pem)?; let mut rng = thread_rng(); let enc_key_bytes = pub_key.encrypt(&mut rng, Pkcs1v15Encrypt, password.as_bytes())?; let encryption_key = hex::encode(enc_key_bytes); // Send proof request to the node let resp = reqwest::Client::new() .post(format!("{node_url}/proof")) .json( &ProofRequest::builder() .job_id(job_id.to()) .file_id(file_id.to()) .file_url(url) .encryption_key(encryption_key) .encryption_seed(encryption_seed.to_string()) .build(), ) .send() .await?; if resp.status().is_success() { println!("✅ Proof request sent successfully"); } else { println!("❌ Failed to send proof request: {:?}", resp); } // 5) Claim DAT reward client.request_reward(file_id, None).await?; println!("✅ Reward requested for file id {}", file_id); Ok(()) } ``` ### Run ```bash cargo run ``` #### Expected output ```bash ✅ Proof request sent successfully ✅ Reward requested for file id ``` # Verify DAT On-Chain # Overview ### Background As decentralized AI Agents become foundational components of the next-generation Web3 infrastructure, their secure, transparent, and verifiable execution is critical. Unlike centralized systems, Web3’s openness introduces new risks: * **Ownership Ambiguity:** Difficult to prove data/model ownership on-chain. * **Authenticity Risks:** Agent behavior and output cannot be trusted by default. * **Lack of Auditability:** No provable link between the used data, the model executed, and the output produced. * **No On-Chain Verifiability:** Inference results can be fabricated without cryptographic accountability. In LazAI, each iDAO manages its own data, model, and agent workflows. While this empowers decentralized autonomy, it also raises the need for a trust-minimized, cryptographically verifiable execution framework. ### iDAO’s Key Security & Privacy Challenges 1. **Data Misuse & Privacy Breach** 1. Sensitive datasets may be exposed or misused during AI processing. 2. Users lack visibility into whether their inputs were securely processed. 2. **Unverifiable Inference** 1. AI inference is typically executed off-chain or locally; users cannot validate results or trace data provenance. 2. The same model may be reused, modified, or forked by different iDAOs without traceability. 3. **Unclear Attribution & Revenue Distribution** 1. Models often rely on multiple data sources; without execution proofs, revenue sharing becomes opaque. 4. **Untrusted Agent Runtime** 1. Many AI Agents run on centralized, uncontrolled hardware—susceptible to tampering or malicious behavior. ### LazAI’s Solution: TEE-First, ZK-Optional, OP-Compatible Verified Execution LazAI introduces a Verified Computing Framework built on three composable execution trust models:
ModePrimary UsageStrengthWhen to Use
TEE ModeDefaultTrusted execution environment (Intel TDX and SGX are both OK) with remote attestationMost inference and fine-tune tasks
TEE + ZK ModeOptional extensionAdds zero-knowledge proofs for selective inputs, outputs, or logic constraintsPrivacy-sensitive or regulatory tasks
Optimistic Mode (OP)BackupEnables fraud-proof-based verification when TEE is unavailableLightweight agents or fallback arbitration
### When to Use ZK or OP ZK and OP serve as optional augmentation to TEE-based computing: **Use ZK when:** * Inputs or outputs must be kept private (e.g., mental health input). * Output must satisfy constraints (e.g., model temperature < 0.9). * Regulatory compliance requires provable logic. **Use OP when:** * Either TEE is not used, or trust assumptions are weaker. * Third-party challengers need to verify computation after execution. * Arbitration or slashing is necessary (e.g., data misuse, forged proofs). ### Cryptographic Proof Models
Asset TypeProof TypePurpose
DatasetMerkle Root + Provenance HashAnchors original data, prevents replacement
ModelTEE Attestation + Param HashVerifies model version and source
InferenceTEE Signature (optional ZK)Verifiable output, optionally private
### Integration with LazAI Infrastructure **Quorum-Based Consensus + VSC Coordination** * Quorum Validators stake on LazChain and form trust domains for iDAO. * VSC (Verifiable Service Coordinator) aggregates proofs from TEE nodes and submits them on-chain. * Verifier Contract on LazChain checks TEE signatures, ZK proofs, or OP dispute proofs. **Challenger Mechanism (for OP Mode)** * Elected challengers monitor inference results and data-model linkage. * Upon detecting fraud, challengers submit Fraud Proofs. * Quorum enforces Slashing, penalizing iDAOs via token burn or DAT reduction. ### Summary LazAI’s Verified Computing architecture provides a hybrid, multi-layered trust framework tailored for decentralized AI ecosystems. With a TEE-first, ZK-assisted, and OP-compatible design, it addresses key pain points in: * Executing private, auditable AI inference tasks * Enforcing data/model provenance * Validating AI agent behavior at low cost * Coordinating decentralized trust via Quorum and VSC This framework transforms iDAOs from isolated compute units into co-verifiable AI entities, anchored by programmable security, fine-grained delegation, and decentralized validation. LazAI’s architecture lays the groundwork for a future where AI is both trustless and transparent, and every computation, dataset, and model update can be proven, traced, and monetized across on-chain and off-chain domains. # Verified Computing Architecture ### Core Components
ComponentDescription
TEE Worker NodesSecure computation nodes running AI tasks (e.g., preprocessing, training, inference) within a trusted enclave, signing all outputs.
iDAOSubmits datasets and models, configures agent execution logic, and selects the validation mode (TEE, TEE+ZK, or TEE+OP).
VSC (Verifiable Service Coordinator)Coordinates proof submission, batches TEE attestations and optional ZK/OP proofs, and submits them to LazChain.
Verifier ContractSmart contract on LazChain that verifies TEE attestations, ZK or OP proofs, and anchors the result hashes on-chain.
Challenger RegistryQuorum-elected members who monitor verification results, issue fraud claims, and trigger slashing when violations occur.
### Execution Lifecycle Flow #### Step 1: iDAO Task Submission **An iDAO submits a task definition, including:** * Data references (IPFS, Arweave, etc.); * Target model or Agent ID; * Expected output type and optional constraints; * Selected verification method: TEE, TEE+ZK, or OP. #### Step 2: Secure Execution in TEE A TEE Worker Node picks up the task; * **Inside a hardware-enforced enclave, it performs:** * Data loading and pre-checks; * Model or Agent execution; * Output generation and hashing; * Signing the result with the TEE’s private key; **If selected, the node may also:** * Generate a ZK Proof for the output computation; * Generate a Fraud Proof-Ready Trace for OP-based setups. #### Step 3: Submitting Proofs to LazChain **VSC aggregates all relevant data:** * TEE Signature (for execution authenticity); * Optional ZK-SNARK (for result verifiability); * Optional OP Trace Hash (for fraud challenge preparation); * Metadata such as model ID, data Merkle root, execution timestamp; * These are submitted as a transaction to the Verifier Contract on LazChain. #### Step 4: On-Chain Verification **The Verifier Contract:** * Checks TEE signature validity using known attestation keys; * Verifies optional ZK or OP proofs; * Anchors result hash and validation status for downstream logic (e.g., DAT reward, access log, or revenue claim); * Emits event logs for traceability. #### Step 5: Dispute and Challenger Mechanism Challengers (Quorum validators) continuously monitor on-chain proof submissions; * **If a suspicious or invalid computation is detected, they can:** * Pull the result + metadata + optional trace; * Recompute the output locally or verify it against OP/Fraud-Proof references; * Submit a FraudProof; **Once validated, the system executes a slashing procedure:** * iDAO penalty: burning of stake or reduction of DAT value; * Challenger reward: incentive for honest verification. ### Optional Verification Modes Explained
ModeWhen to UseAdvantagesOverhead
TEE OnlyTrusted agents in performance-critical use cases; fast, low gasHardware-based trust, ultra-low gasNeeds TEE-compatible hardware
TEE + ZKHighly sensitive data, regulatory audits, or public agent usePublic verifiability, cryptographic guaranteesMedium gas cost, higher latency
OPFor open models with fast finality and community arbitrationTransparent fraud resolution, no ZK setupRequires fraud monitoring and challenge periods
### Security Guarantees
LayerProtectionMechanism
Execution TrustCode and data cannot be tampered with during runtimeHardware TEE isolation, remote attestation
Verifiable OutputOutputs are provably derived from claimed inputsZK-SNARK or OP Fraud-Proof
Data PrivacyData processed inside secure enclaves, not exposed on-chainTEE memory isolation, encryption
Dispute ResolutionAny party can challenge invalid resultsOn-chain challenger registry with incentives
### Integration with Consensus and Reward Mechanism * All proofs submitted via VSC are included in blocks through the Quorum-Based BFT consensus; * iDAO stakes, DAT updates, and model access rights are governed by verified task results; * Fraud proofs or confirmed proofs serve as inputs to reward allocation, slashing, and token distribution via Verifier and Settlement Contracts. # Contract & Execution Flow
### Core Smart Contract Modules LazAI’s Verified Computing system consists of the following core contract modules:
ContractResponsibility
Verifier ContractCore validator that receives proofs from the VSC and verifies TEE signatures, ZK proofs, or OP-based fraud evidence on-chain.
VSC CoordinatorMiddleware that aggregates proofs from TEE nodes, including optional ZK/OP proofs, and submits them to the Verifier contract.
Challenger RegistryMaintains a list of Quorum-elected challenger nodes and tracks their activity, reputation, and rewards.
ExecutionRecordStores metadata of each computation task, including result hash and verification status.
Settlement ContractHandles reward allocation and slashing based on verification results, impacting DAT ownership and value.
### Verifier Contract Interface `interface IVerifier {` `function submitTEEProof(` `bytes calldata taskId,` `bytes calldata resultHash,` `bytes calldata teeSignature,` `bytes calldata attestationReport` `) external;` `function submitZKProof(` `bytes calldata taskId,` `bytes calldata zkProof,` `bytes calldata publicSignals` `) external;` `function submitFraudProof(` `bytes calldata taskId,` `bytes calldata evidence,` `address challenger` `) external;` `function verifyResult(bytes calldata taskId) external view returns (bool valid);` `}` ### Task Lifecycle Flow Diagram
### Full Execution Lifecycle This section outlines the step-by-step process for verifiable execution under each supported mode: TEE, TEE+ZK, and OP. Each flow ensures secure and auditable AI computation within the LazAI framework. #### Step 1: Task Submission by iDAO The iDAO initiates a computation task via an off-chain UI or dApp, sending it to the VSC for orchestration. **Submitted Fields:** * **taskId:** Unique hash for the task; * **dataRef:** Dataset reference (e.g., IPFS, Arweave hash); * **modelId:** The model or Agent identifier to execute; * **params:** Inference or training parameters; * **verifyMode:** Enum specifying TEE, TEE+ZK, or OP. The VSC stores this metadata and assigns the task to eligible TEE nodes. #### Step 2: Secure Execution Inside TEE The assigned TEE Worker Node performs the task inside an isolated enclave: **In-Enclave Process:** 1. Initialize environment using the specified dataset and model; 2. Run computation (e.g., forward pass, token prediction, classification); 3. Generate resultHash from the output; 4. Sign the result using TEE’s private key; 5. Attach remote attestation report. **Depending on verifyMode, the node additionally:** * Generates a ZK-SNARK proving the correctness of the computation without revealing input/output (for TEE+ZK mode); * Prepares a Fraud-Proof-ready execution trace, hashed and stored off-chain (for OP mode). **Security Guarantees:** * Execution is isolated and tamper-resistant; * Signed results are cryptographically bound to the specific TEE environment. #### Step 3: VSC Aggregation and Proof Packaging Once execution is complete, the VSC (Verifiable Service Coordinator) aggregates the following:
DataIncluded WhenPurpose
TEE SignatureAlwaysConfirms execution occurred inside TEE
ZK ProofTEE+ZK onlyProves result validity without exposing data
OP Trace HashOP onlyEnables later challenge by a third party
Execution MetadataAlwaysIncludes modelId, dataRoot, execution timestamp, etc.
The VSC then formats this package and submits it as a transaction to the Verifier Contract on LazChain. #### Step 4: On-Chain Verification by Verifier Contract The Verifier Contract receives the task package and performs the following steps: **TEE Mode** * Verifies the **TEE signature** using trusted attestation keys; * Validates that resultHash and attestation correspond to the original request; * Marks task as **verified** and stores the output hash on-chain. **TEE + ZK Mode** * Verifies the **TEE signature** as above; * Executes on-chain ZK verifier to validate the **ZK-SNARK proof**; * Records both resultHash and proofResult in ExecutionRecord. **OP Mode** * Stores the result and OP Trace Hash; * Opens a **challenge window (**e.g., 12–24 blocks) for registered challengers to submit fraud claims; * If no valid fraud proof is submitted within the window, the result is finalized as valid. #### Step 5: Post-Verification Hooks **Once verification is complete:** * The **ExecutionRecord** module stores taskId, verification status, resultHash, and timestamp; * The **Settlement Contract**: * Increases or adjusts DAT value for contributing iDAOs; * Releases access credits or rewards based on usage; * Optionally triggers stake updates or slashing (in case of OP fraud). All results are publicly queryable and indexed on LazChain for audit, traceability, and downstream data monetization. ### Module-to-Module Interaction Summary
SourceTargetData TransmittedPurpose
iDAOVSCtaskId, modelId, dataId, verifyModeTask configuration
TEE NodeVSCresultHash, signature, attestationSecure result
VSCVerifierProofs and metadataOn-chain validation
VerifierExecutionRecordStatus and result hashTask tracking
VerifierSettlementvalid status, DAT infoReward or slashing
### Proving Dataset and Model Ownership To establish clear and verifiable ownership of datasets and models within LazAI, the following protocol is implemented between iDAO users, Quorum nodes, and the LazChain infrastructure: 1. **Initial Anchoring with TEE Attestation**\ When a user (or iDAO member) first uploads a dataset or model to a Quorum, the selected TEE Worker Node performs a cryptographic attestation by: 1. Computing the data hash (e.g., SHA256 of the dataset or model); 2. Binding it to the uploader’s public key or LazChain address; 3. Signing this tuple using the TEE’s private attestation key. 2. **Ownership Registration via LazChain**\ The Verifiable Service Coordinator (VSC) packages this attestation into a LazChain transaction, which includes: 1. The data or model hash; 2. The uploader’s public address; 3. The TEE signature and timestamp. The Ownership Registry Contract stores this mapping, establishing an on-chain link between data hash and rightful owner. 3. **Consensus-Based Verification and Transfer**\ All future operations involving the dataset - whether validation, licensing, delegation, or ownership transfer - must be registered as consensus-approved transactions on LazChain. This ensures tamper-proof traceability and cryptographic auditability. 4. **Ownership Query and Privacy-Preserving Claims**\ To prove ownership, a user simply queries the on-chain registry for the binding between their address and the data hash.\ In cases where the user must prove specific dataset properties (e.g., contains 10,000 labeled entries, complies with regulatory filters) without revealing the raw data, a Quorum node may generate a Zero-Knowledge Proof (ZKP) certifying the claim, which can then be verified on-chain. ### Computing node * Users can indirectly query and use encrypted data through computing nodes, including fine-tuning and inference. * Verify that nodes control accounts that can access the data through contracts. * Joint data analysis allows users to securely process information across multiple iDAOs. # Overview Data evaluation and alignment are core pillars of LazAI’s decentralized AI ecosystem, addressing critical challenges in ensuring data quality, relevance, and incentive alignment across distributed contributors. In a landscape where data fragmentation, privacy concerns, and inconsistent quality hinder AI progress, LazAI’s framework establishes a trust-minimized, verifiable pipeline to assess data value, align it with AI model objectives, and reward contributors fairly. At its core, this system enables:
* Objective Data Quality Assessment: Standardized and context-aware metrics to evaluate data integrity, accuracy, and utility for specific AI tasks (e.g., training, inference, or fine-tuning). * Alignment with Model Goals: Mechanisms to ensure data relevance to target AI use cases (e.g., medical datasets aligned with diagnostic models) through community-driven curation and on-chain validation. * Transparent Incentives: Direct linking of data evaluation results to economic rewards (via the value field of DAT tokens), ensuring contributors of high-quality, aligned data are fairly compensated. * Privacy-Preserving Validation: Leveraging cryptographic tools (e.g.,TEEs, ZKPs) to assess data without exposing raw information, critical for sensitive domains like healthcare or finance. By integrating these capabilities, LazAI resolves the paradox of decentralized data, enabling scalability and diversity while maintaining the rigor required for reliable AI outcomes.
# Architecture
LazAI’s Data Evaluation and Alignment architecture is built on three interconnected layers, designed to operate seamlessly within its broader blockchain and iDAO governance framework: ### 1. **Data Submission & Metadata Anchoring Layer** This layer handles initial data ingestion, ensuring provenance and basic integrity before evaluation.
* iDAO-Driven Submission: Data contributors (individuals or organizations) submit datasets through their affiliated iDAOs, which act as curators. Each submission includes structured metadata: * Source attribution (via cryptographic signatures). * Domain tags (e.g., “biomedical,” “financial transactions”). * Format specifications (e.g., text, images, tabular data) and preprocessing logs. * On-Chain Anchoring: A hash of the dataset and its metadata is recorded on the LazChain, creating an immutable audit trail. This hash is linked to the contributor’s DAT token, establishing initial ownership and traceability. ### 2. **Evaluation Engine Layer** This layer executes multi-dimensional data assessment, combining automated checks and community validation.
* Automated Quality Metrics: * **Integrity Checks:** Cryptographic verification of data hashes to detect tampering. * **Statistical Validity:** Tools to measure noise, duplication, and coverage (e.g., for text data, perplexity scores; for images, resolution and labeling consistency). * **Privacy Compliance:** Scans for sensitive information (e.g., PII) using zero-knowledge proofs to ensure compliance with iDAO-defined policies. * Contextual Alignment Checks: * **Model Compatibility:** For datasets submitted to train specific models (e.g., a sentiment analysis model), the engine verifies alignment with the model’s input schema and objective (e.g., labeling consistency with sentiment labels). * **Domain Expertise Integration:** iDAOs can appoint domain-specific validators to manually review high-stakes data (e.g., clinical trial records), with their assessments weighted via on-chain voting. * Incentivized Challenges: External “challengers” can submit fraud proofs to dispute evaluation results (e.g., identifying hidden biases in a dataset). Successful challenges earn DAT rewards, while invalid claims result in penalties, ensuring rigor. ### 3. **Alignment & Reward Layer** This layer ties evaluation outcomes to economic incentives and iterative improvement.
* **Dynamic Value Scoring:** Each dataset receives a Data Quality Score (DQS) based on evaluation results, encoded in its associated DAT token. The DQS influences: * Access privileges (e.g., high-DQS data is prioritized for premium AI models). * Reward calculations (contributors earn a share of model revenue proportional to their data’s DQS and usage frequency). * **Feedback Loops:** Post-deployment, the system tracks how data impacts model performance (e.g., inference accuracy, reduction in hallucinations). This data is fed back into the evaluation engine to refine future assessments—for example, a dataset that improves model accuracy over time sees its DQS increase. * **iDAO Governance:** Each iDAO sets its own evaluation policies (e.g., weighting of automated vs. manual checks) via on-chain proposals, ensuring alignment with community values (e.g., privacy-focused iDAOs may prioritize anonymization metrics). By integrating these layers, LazAI’s Data Evaluation and Alignment architecture transforms fragmented, untrusted data into a verifiable, high-quality asset—one that drives AI innovation while ensuring contributors are fairly rewarded for their contributions. # Technical Design ### Duplication Detection We can divide data into structured data and unstructured data. For structured data, we can adopt hash-based partitioning technology. First, calculate the hash value (such as SHA-256) for key fields, then divide the data into 100 buckets according to the last two digits of the hash value. Each bucket is processed separately for duplicate detection to reduce memory and computational overhead. For unstructured data, we can also mainly divide it into text and image. For text data, we mainly use embedding technology to first convert the text into vectors and calculate the cosine similarity between vectors. When the similarity is ≥ 0.95, it is judged as highly similar, and a lower weight score is given to ensure the diversity of data within a single iDAO organization. For image data, we can first use a classification model to determine the model category, and then use a perceptual hashing algorithm. For example, scale the image to 8\*8 pixels, convert it to a grayscale image, calculate the average pixel value, and generate a hash value after comparing each pixel with the average value. Images with similar hash values are considered duplicates or highly similar. ### Quality Assessment For text data, we directly calculate the perplexity of the data through the LazAI language reasoning model. The lower the perplexity, the better the coherence and standardization of the text, and the higher the information density. For image data, we mainly evaluate resolution and label consistency. ### Context Alignment Detection - Model Training Weight Analysis Monitor the change of weights with data during training: If a batch of data significantly reduces the model's loss function (such as MSE for regression tasks and cross-entropy for classification tasks), it indicates that this data plays a great role in model optimization. By calculating the gradient of the loss function for each batch of data, the data with the gradient direction consistent with the direction of loss minimization and a large amplitude is more important for model training. Adopt importance sampling: Allocate probabilities according to the contribution of data to weight updates. Data with high probabilities is more aligned with the model's goals. ### Context Alignment Detection - Model Inference Verification After training, use the data for inference testing: For example, in a fraud detection model, data that can correctly classify known fraud/non-fraud cases has a high alignment degree. Calculate metrics such as precision, recall, and F1-score on the validation set. Higher scores indicate that the data quality is more suitable for the model's task. Analyze the confidence of model predictions: In classification tasks, data with a confidence close to 1 for the correct category has strong consistency with the patterns learned by the model and a high alignment degree. #### DQS CalculatioCalculation DQS is calculated using a weighted formula that synthesizes multidimensional indicators, as follows: S = w1 \* DS + w2 \* AS + w3 \* CAS where w1, w2, and w3 are weights, DS stands for Duplication Score, AS for Accuracy Score, and CAS for Model Context Alignment Score. # Consensus Protocol The Trusted Execution Layer forms the backbone of LazAI, ensuring secure, verifiable, and decentralized AI execution and governance. It leverages blockchain-based validation, high-performance execution, and scalable data availability mechanisms to optimize resource utilization while maintaining data integrity and computational trust.
### PoS + Quorum-Based BFT Consensus Protocol To ensure data trustworthiness and execution reliability, LazAI employs a Quorum-Based Byzantine Fault Tolerant (BFT) consensus mechanism. Each Quorum functions as a decentralized iDAO responsible for governing, verifying, and securing AI-related data and computational processes. **LazAI Consensus Layer has the following three features:** 1. **Decentralized Data Verification:** Each iDAO operates independently to validate datasets, training models, and AI agent execution before anchoring them on-chain. 2. **Optimized Off-Chain Storage:** AI datasets remain off-chain, while their cryptographic proofs and metadata are stored on LazChain, minimizing storage costs. 3. **High-Performance Data Processing:** The Quorum consensus model enables parallel verification and validation, reducing latency for AI model updates and execution. **Its main advantages are as follows:** * **Reduces Centralized Risk:** No single entity controls data governance, ensuring resistance to manipulation and censorship. * **Transparent & Immutable:** All verification events and decisions are stored on LazChain, providing full auditability. * **Scalable Data Governance:** iDAOs dynamically adapt to evolving AI datasets, allowing continuous validation and dispute resolution. By integrating a Quorum-based BFT consensus, LazAI ensures high availability, low latency, and verifiable AI execution, forming a robust foundation for decentralized AI governance. \
# Settlement Layer The Settlement Layer transforms AI-related data, models, and agents into tokenized assets, ensuring secure, traceable, and programmable ownership. **Key Functionalities are as follows:** 1. **Immutable AI Asset Registration:** Training datasets, model weights, and execution parameters are permanently anchored on LazChain, ensuring provenance. 2. **Data Anchoring Token (DAT) Management:** Every issuance, transaction, ownership transfer, and access control event related to AI assets is immutably recorded on-chain. 3. **Privacy-Preserving Provenance Tracking:** Utilizes Zero-Knowledge Proofs or TEE Proofs to validate dataset authenticity while protecting sensitive AI data. By anchoring AI assets on a decentralized ledger, the Settlement Layer guarantees integrity, accessibility, and compliance, paving the way for a trustless AI economy. # Execution Layer The Execution Layer is designed to support verifiable AI computation, inference optimization, and seamless AI asset deployment. This layer ensures that AI agents and models operate efficiently and transparently within LazAI’s decentralized ecosystem. **Core Capabilities:** * **Verified Computing Framework:** LazAI establishes trust in AI-generated outputs, ensuring that inference results, training processes, and data integrity are independently verifiable. * **Parallel EVM Execution for AI Workloads:** AI asset-related transactions (e.g., dataset validation, model licensing) benefit from parallelized execution, improving scalability. * **Inference Engine Optimization:** Supports low-latency, high-throughput AI inference and integrates hardware acceleration for AI reasoning (e.g., CPU/GPU/TPU optimization). By implementing trustless AI execution mechanisms, the Execution Layer ensures transparency, security, and scalability for AI applications in Web3.
# Data Availability Layer AI-driven applications require continuous access to high-quality, verifiable data. The Data Availability Layer ensures that AI datasets, training models, and inference results remain accessible, transparent, and cryptographically secure. #### Key Functionalities: 1. **On-Chain & Off-Chain Data Anchoring:** 1. AI datasets and execution metadata are hashed and stored on Blockchain for traceability and verification. 2. Supports verifiable off-chain storage solutions such as IPFS, Arweave, and decentralized storage networks, ensuring permanence and censorship resistance. 2. **Cross-Platform Data Interoperability:** 1. LazAI enables trusted data interactions between Web2, Web3, and decentralized AI models. 2. Integrates APIs for traditional Web2 data sources, public datasets, and enterprise AI systems, allowing AI agents to leverage diverse information pools. 3. **Privacy-Preserving Verification:** 1. Uses ZK/TEE Proofs and Fraud Proofs to validate off-chain data integrity without exposing raw information. 2. Supports Optimistic Proofs to streamline dispute resolution while maintaining data accountability. #### Onchain Reputation System: To ensure high-quality AI datasets, LazAI introduces a reputation-based scoring mechanism for data sources and contributors: * **Dynamic Trust Scores:** Data providers, AI agents, and model trainers are assigned trust ratings based on usage history, verification results, and community feedback. * **Reputation-Driven Incentives:** High-trust contributors gain priority listing in the LazAI ecosystem, while low-trust providers face penalties or dataset deprecation. By enabling multi-layered data verification, decentralized storage, and Web3-compatible interoperability, the LazAI Data Availability Layer ensures continuous access to reliable AI datasets, forming the foundation for a scalable, trustless AI ecosystem.
# Introduction LazAI’s Quorum-Based BFT (QBFT) consensus is a modular and scalable consensus protocol optimized for AI-centric decentralized systems. It blends practical Byzantine Fault Tolerance (pBFT) with a Quorum-based voting mechanism to ensure efficient validation, integrity, and liveness in a multi-agent AI data network.
### Key Entities
ComponentRole
QuorumA logical group of validators (iDAO members) responsible for data validation.
ProposerA rotating member of the quorum responsible for proposing the next block/data state.
ValidatoriDAO participant who verifies, signs, and votes on proposed blocks.
ChallengerExternal party capable of submitting fraud proofs or challenges.
### Design Principles * **AI Data-Aware Consensus:** Handles metadata-rich, non-deterministic AI data (e.g., dataset hashes, ZK proofs, computation logs). * **Quorum-Based Delegation:** Only assigned quorums participate in consensus, improving scalability. * **Dynamic Quorum Rotation:** Quorum members are periodically re-elected or rotated for decentralization. * **Hybrid Validity Layer:** Supports ZK-SNARK/TEE proofs and Optimistic Proofs (OP) as validity inputs. # iDAO-Quorum Interaction VSC (Verifiable Service Coordinator)-Based iDAO-Quorum Interaction Protocol
### Security Delegation via Stake-Based Quorum Integration Each Quorum node participating in LazChain’s consensus mechanism is required to stake native tokens as a guarantee of honest behavior. Through this staking model and potential external collaborations (e.g., restaking, cross-chain validation, or inter-protocol delegation), iDAOs indirectly inherit the economic security of LazChain. By leveraging Quorum nodes that are economically aligned through stake commitments on LazChain, iDAOs benefit from shared security guarantees without replicating full consensus overhead. ### POV/Model/Agent Updates are Transmitted via VSC to Quorum for Consensus Whenever an iDAO performs updates, whether submitting new POV Inlet data, publishing a model, or deploying an AI Agent, these changes are packaged as service transactions and routed to the relevant Quorum via the VSC protocol. Each Quorum, operating under a Byzantine Fault Tolerant (BFT) consensus, independently validates and reaches agreement on the transaction outcome before anchoring them to LazChain. The VSC layer ensures that any AI-related state change proposed by iDAOs (e.g., new models, retraining outputs, or agent updates) is routed to the appropriate Quorum and finalized through localized BFT consensus before being registered on-chain. ### Proof Submission $ Asynchronous Validation via VSC After consensus on the high-level update, VSC asynchronously dispatches verification artifacts—such as ZK proofs, Optimistic Proofs, or TEE attestations—to the relevant Quorum nodes. These proofs serve as cryptographic evidence that the update was generated under valid computational assumptions and that the iDAO’s declared actions were faithfully executed. VSC acts as the communication bridge between iDAO and Quorum validators, coordinating the off-chain-to-on-chain delivery of verifiable computation proofs to be asynchronously validated and logged. ### Challenger Arbitration and Slashing Procedure Within each Quorum, a rotating set of Challenger nodes is elected to perform near real-time audits. These nodes continuously pull iDAO-submitted data and associated proofs from LazChain. If a Challenger detects inconsistency - such as an inference proof not matching the declared model weights - it can trigger a slashing dispute. #### **This initiates the following:** * Immediate freeze of the suspicious iDAO update. * Verification of the challenger’s claim through multi-round consensus. * If valid, slashing of: * Staked tokens by the responsible Quorum node (if it facilitated an invalid consensus). * DAT assets or usage credits associated with the offending iDAO. Challengers serve as protocol-native auditors, empowered to initiate a punitive slashing process whenever verifiable misconduct or falsified AI computations are detected. This creates a high-integrity, economically-incentivized deterrent mechanism. # Quorum-Based BFT Protocol
### Quorum-as-Validator: BFT Participation Each Quorum in LazAI is treated as a full validator node in the BFT consensus layer of LazChain. Quorums participate in ordering and validating transactions related to AI datasets, models, and inference proofs. * **BFT Layer:** Built on a Byzantine Fault Tolerant consensus mechanism, where Quorums serve as the proposers, voters, and committers. * **Quorum ID:** Each Quorum has a registered QuorumID and validator weight based on its staking level and historical performance. * **Deterministic Rotation:** Block proposal is rotated across Quorums; performance and slashing affect rotation weights. ### iDAO ↔ Quorum: Trust-Coupling via Economic Bonding Each iDAO must establish explicit trust relationships with one or more Quorums to publish and validate AI assets. Two flexible trust modes are supported: * **Restaking Mode:** iDAO stakes native tokens (e.g., $LAZ) to the target Quorum, delegating verification responsibility. Slashing penalties apply for fraud or invalid proofs. * **DAT-Backed Trust Mode:** iDAO may mint AI assets (e.g., datasets or models) as DATs and request endorsement by a Quorum. In this mode: * The Quorum acts as a verifier and partial staker of the DAT. * The DAT becomes slashing-enabled, provable fraud leads to partial revocation or burn of DAT value. * Revenue sharing can be jointly configured between iDAO and Quorum based on the shareRatio. ### Quorum as a Hash-Proven Off-Chain Storage Gateway
Quorums are not only validators, but also serve as off-chain AI storage coordinators. They host: * Raw datasets (IPFS/Arweave/Filecoin), * Fine-tuned models, * Inference results, execution logs, and * OP/ZK/TEE-based proofs. Only the corresponding hash commitments and metadata are posted on-chain to minimize LazChain storage load. iDAOs fetch training data from Quorums and submit updates via Verifiable Service Coordinator (VSC). ### VSC: Orchestrated Trustless Coorination The Verifiable Service Coordinator (VSC) bridges iDAO outputs and Quorum consensus: * **Transaction Submission:** iDAO sends POV Updates, Model Anchors, Inference Outputs, and Verification Proofs to the VSC. * **Proof Dispatching:** VSC asynchronously dispatches proof bundles (e.g., OP/ZK/TEE) to corresponding Quorums. * **Quorum Consensus:** Quorums validate the bundles and finalize them on LazChain via BFT. ### Challenger-Based Slashing Protocol To ensure iDAO integrity and data authenticity, Challenger nodes are elected from within each Quorum: * **Near-Real-Time Monitoring:** Challengers continuously pull Quorum-endorsed proofs from LazChain. * **Fraud Detection:** If an iDAO is found to have submitted a model/proof inconsistent with the training dataset or usage policy: * A fraud proof can be submitted. * If verified, the iDAO is slashed (token stake or DAT-backed value). * The challenger is rewarded. * **Slashing Scope:** * Native token slashing from restaking. * DAT shareRatio burn from endorsement. * Temporary blacklist from specific Quorums. #### I**nnovation Points vs Traditional BFT**
DimensionLazAI LQBCPTraditional BFT
Validator AbstractionQuorums serve as both consensus validators and AI data providersValidators focus purely on block finality
Slashing LogicMulti-source: token-based, asset-based (DAT), behavior-basedTypically token-only
Trust FlexibilityiDAO dynamically bonds to trusted Quorums via staking or asset endorsementStatic validator set
Proof IntegrationBuilt-in OP/ZK/TEE verification with off-chain data bindingNot natively data-aware
Data Provenance LayerHash-based anchoring via Quorum storageNot data-integrated
Modular IncentivesiDAO ↔ Quorum reward agreements via DAT share ratiosMonolithic block reward or fee
# Slashing & Challenger System ### Purpose Ensure data validity and computation integrity by enabling any participant to challenge dishonest or incorrect submissions (e.g., invalid datasets, forged proofs, malicious inference). If proven correct, the challenger is rewarded, and the malicious party is penalized through slashing. * **Fraud Detection:** Any party can submit a FraudProof against a committed block. * **Resolution:** * LazChain executes a fraud arbitration contract using on-chain or TEE-based verification. * If the proof is valid: * Proposer is slashed * Validating signers are penalized (if collusion proven) * Challenger is rewarded ### Core Components
ComponentRole
ProposerThe validator/quorum member who proposed the block or submitted the AI asset/proof.
ChallengerAny external actor who submits evidence that a committed dataset, proof, or result is invalid or fraudulent.
Arbitration ContractA smart contract that validates fraud proofs (ZK, Merkle, TEE attestations) and enforces punishment/reward.
Slashing PoolStaked tokens held by proposers and quorum validators, which can be reduced (slashed) in the event of fraud.
Challenge WindowThe period (e.g., 100 blocks) during which a committed block/result can be challenged.
*** ### Challenge Flow #### Step 1: Fraud Detection A challenger observes that a committed dataset, model, or inference result is invalid. **Examples:** * Malformed or manipulated dataset hash * Proof mismatch (ZK, OP) * Inference result contradicts source input **They prepare a Fraud Proof:** `struct FraudProof {` `bytes32 disputedBlockHash;` `bytes challengeData;` // could be Merkle branch, ZK transcript, etc. `uint256 timestamp;` `address challenger;` `}` #### Step 2: Challenge Submission The challenger calls: `challengeBlock(bytes32 disputedBlockHash, FraudProof calldata proof)` The contract: * Checks challengeWindow validity (block not too old) * Validates the `proof.challengeData` * Calls appropriate verifier (e.g., MerkleVerifier, ZKVerifier, TEECertifier) #### Step 3: Arbitration & Result If the fraud proof is **valid**:
ActionEffect
🏆 Challenger winsReceives reward from slashing pool (e.g., 10% of stake)
⛔ Proposer slashedTheir stake is burned or redistributed
⚠️ Quorum Validators (optional)Can be penalized (reduced rewards, stake slashing) if collusion proven
❌ Fraudulent block/resultMarked invalid, removed or reverted in local state
🧠 DATs mintedMay be burned or frozen if tied to fraudulent data
If the fraud proof is **invalid**: * The challenger may lose a small bond (anti-spam) * Block and proposer remain valid ### Challenge Types
TypeDescriptionVerifier
ZK ChallengeSubmitted proof is invalid or unverifiableZKVerifier
TEE ChallengeTEE signature or report mismatchTEECertifier
Inference DiscrepancyOutput does not match expected inferenceOP / Result Replay
Dataset IntegrityDataset hash does not match anchorMerkleVerifier
Behavioral FraudAgent performs unauthorized behavior (e.g. overcharge, illegal write)AgentAuditContract
### Slashing Logic
ActorConditionSlash Amount (example)
ProposerProven to have submitted invalid block/proof30%–100% of stake
ValidatorSigned off on invalid block (optional check)10%–30% if collusion
ChallengerSubmitted invalid challengeForfeit 1%–5% challenge bond
### Challenge Timing Parameters
ParameterDescriptionExample Value
challengeWindowMax blocks after proposal that a challenge is valid100 blocks
verificationTimeoutMax time for contract to verify a proof1 minute
slashingDelayDelay before applying slashing, to allow appeals10 blocks
### Integration with DAT * Fraudulent data detected → affected DAT tokens are frozen or burned. * Ownership reverted or flagged in registry. * Affected classId can be blacklisted temporarily. * Future token mints in that class may require stronger verification (e.g., quorum + external verifier). ### Incentive Summary
RoleIncentive
ChallengerWins reward from slashed stake if proof is valid
ValidatorEarns block rewards, but penalized for signing off on invalidity
ProposerGets rewards if honest, slashed if caught submitting invalid work
iDAOMaintains reputation and stake power through accurate participation
#### Example Dataset submitted with wrong hash, minted as DAT. A challenger finds the original file on IPFS and submits a Merkle branch proving mismatch. challengeBlock() is called, validated → proposer slashed, challenger rewarded, DAT frozen. # Quorum Rotation & Benefit ### Dynamic Quorum Rotation * Periodically or based on time/epoch: * A staking contract selects the next quorum using stake-weighted randomness. * Top-N iDAO nodes are assigned to the next active quorum. * Transition is smooth and predictable (e.g., every 100 blocks). ### Benefits of LazAI QBFT
VerifiabilitySupports cryptographic proofs for AI models and datasets.
ScalabilityQuorum sharding ensures horizontal scalability.
AI-Native ValidityDirect integration with ZK-SNARKs, OP, and TEEs.
Incentivized SecurityBuilt-in slashing & challenge rewards system.
Modular IntegrationWorks with DAT token minting, iDAO governance, and Alith agent execution.
# Architecture ### Overview
### DAT-Centric Data and AI Pipeline
### Core Component
# E2E Process LazAI, we can divide workflows into data setup process, data usage process, and inference process according to different roles, corresponding to users who want to contribute data to obtain tokens and exchange tokens for data or models. ### Data Setup Process
### Data Usage & Inference Process
LazChain nodes not only consist of regular execution nodes and validation nodes, but also provide AI nodes (AI Execution Extension) for routine AI task execution such as model pulling and deployment, data processing, on-chain inference, and other processes. Users provide POV and send the data to the blockchain in the form of transactions. POV is usually stored in the form of tensors and can be transmitted and stored in blocks when necessary. Users can submit publicly available tensor data or ZK proof of data to the blockchain, and provide the required model ID for subsequent inference tasks. Meanwhile, LazAI provides the Alith framework to assist users in data processing, format conversion, compression and interaction with LazChain. When LazChain receives a POV, it will execute the corresponding contract code to request the DAO contract to perform data fingerprint verification. After verification is passed, the DAO contract can pull remote or local models to establish inference services in the AI node. The basic capabilities required for the inference services and the coprocessor acceleration are provided through AI precompile contracts. After the user submits the POV data, they can send a data or inference request to LazChain to obtain data verification. After the data verification is completed, the data contribution is recorded and the corresponding DAT token is obtained. In addition, the LazAI network settles based on data and computing resource usage and includes a dynamic strategy for fees based on community and market conditions. For details, please refer to the settlement section. # POV Data Structure POV is a protocol and standard for data unification In LazAI. A basic POV data includes the following fields: \ A basic POV data includes the following fields: `message POV {` `bytes data_hash = 1;` `string data_tag = 2; // LLM weight, dataset metadata, user info, inference prompt` `string data_type = 2; // f32, f16, …` `Bytes data_size = 3; // data tensor size` `Tensor data = 4;` `uint64 timestamp = 5;` `Proof proof = 6; // Optional data proof` `}` Considering that different users may have different data sources and modalities, which typically include text, speech, images, videos, and other modalities as well as different formats, we need to unify them into a fixed POV format. POV uses tensors for encoding and decoding, which records information such as hash, class, and timestamp of the data. Users need to submit the compressed POV data format for uploading on the chain. ### Privacy Data & Public Data At LazAI, we encourage open data formats and content, so POV supports storing data in a public form on the chain that anyone can access. However, for private data, LazAI also supports off chain storage. LazAI can efficiently verify the integrity and consistency of off chain data without storing all data on the chain. LazAI provides higher privacy protection and trustworthiness assurance for off chain data, avoiding potential risks of centralized data sources and promoting the development of decentralized data governance. iDAO，Its function is similar to that of a traditional data center, but the data does not need to be directly stored on the blockchain. Users only need to submit a proof for uploading to the blockchain. LazAI mainly supports private data on-chain. In theory, it can support data of any size to calculate its credentials on-chain. For public data, it will be limited to 32K, which is similar to the storage requirements of the chain and the context window of general AI models. Through the Alith Agent toolkit, users can perform data preprocessing and proof calculation locally, and upload data to the LazAI network, making the data available but invisible. ### Privacy Data Workflow In LazAI, we use OpenPGP to encrypt and decrypt the privacy data. OpenPGP encryption process: Randomly generate a Key and use it to encrypt data using a symmetric encryption algorithm. Finally, use an asymmetric encryption algorithm (RSA) to encrypt the recipient's Key using the receiver's public key to obtain encrypted data. Specifically, we obtain a random key from the user's Web3 wallet, such as Metamask, and use this random key to encrypt the user's private data. This process verifies the sender's identity, and then uses the asymmetric encryption algorithm (RSA) to encrypt the recipient's key (which can be obtained by requesting LazAI's data registration contract to obtain the public key) to obtain the encrypted data. We then upload the encrypted data to DA (such as IPFS, Google Drive, or Dropbox), and register the encrypted data URL and Encrypt key to the LazAI contract. The test data verifier can decrypt the encrypted key using the private key and download the private data for decryption through the URL. The decryption process is placed in TEE to ensure data security. Will not be tampered with, and then decrypted data and TEE generates proof and uploads it to LazAI contract for verification.

### How to expand the Data Structure Considering that user data is mainly used for model training and on chain inference, the only guarantee is that they need to meet the input requirements of the model. Therefore, LazAI provides the Alith Agent framework and Model Context Protocol (MCP) to complete multimodal and various data format preprocessing, as well as POV tensor data conversion. The advantage of this is that we can support as many types of data as possible at the application layer without modifying the blockchain network and protocols. # AI Execution Mechanism ### AI Node (AI Execution Extension) The AI node mainly includes an EVM-compatible LazVM for AI computing and gas settlement, and its main process is as follows:
### Request For AI training and inference, users send inference or training requests to AI nodes. Taking an inference request as an example, it is compatible with the OpenAI API. Users need to provide additional DAT ID for additional data acquisition, wallet signature and nonce for inference fee settlement.
### LazVM * EVM-Compatible: Ensures compatibility with existing Ethereum Virtual Machine tools and smart contracts. * AI Computing: Specialized execution environment for AI workloads. * Gas Settlement: Integrated gas mechanism to track and settle computational costs. #### AI & Proof Precompile * **Computation Orchestration:** Coordinates between LazVM and GPU Coprocessor including model loaders, tokenizers, embedders, tensor kernels, attention kernels and SIMD, etc. * **Proof Verification:** Validates computation proofs returned from GPU Coprocessor including proof kernels. Besides, we will reserve op and zk proof interfaces to support multiple op and zk systems: e.g., STARKs, PLONK or any component from zkMIPS. #### GPU Coprocessor * Accelerated Computing: Dedicated hardware acceleration for AI computations. * Proof Generation: Creates cryptographic proofs of correct computation execution. * Resource Monitoring: Tracks computational resources used during inference. The Execution Layer is designed to support verifiable AI computation, inference optimization, and seamless AI asset deployment. This layer ensures that AI agents and models operate efficiently and transparently within LazAI’s decentralized ecosystem. By implementing trustless AI execution mechanisms, the Execution Layer ensures transparency, security, and scalability for AI applications in Web3. ### Settlement Layer The Settlement Layer transforms AI-related data, models, and agents into tokenized assets, ensuring secure, traceable, and programmable ownership. **GasAI = α⋅FLOPs+γ** **GasInference = β⋅Mempeak** **GasEstimate = P ⋅ T** **Where:** * α = FLOPs rate coefficient (adjustable via governance). * β = Memory peak rate coefficient (adjustable via governance). * γ = Base gas cost for AI operations including data store and computing resources. * FLOPs = Floating Point Operations (computational workload metric). * Mempeak = Peak memory usage during computation. In addition, here we refer to EIP1559 to dynamically adjust the gas price, which includes a basic fixed fee and a part based on market conditions. ### Quorum-based BFT Consensus Protocol & iDAO LazAI blockchain leverages a Quorum-based Byzantine Fault Tolerance (BFT) consensus mechanism, distributing data governance and storage across multiple decentralized Quorum organizations to ensure both reliability and transparency. * Each Quorum operates as an iDAO, functioning similarly to a traditional data center but without the need to store data directly on-chain, significantly reducing on-chain storage costs. * These iDAO organizations reach consensus to validate and ensure the trustworthiness of off-chain data, enabling its rapid and efficient delivery to both on-chain and off-chain agents, while maintaining high availability and low latency. #### The main responsibilities of iDAO include: 1. Providing Trustworthy AI Data Sources or AI Flow\ Offering reliable data sources or AI workflows to other individuals or organizations, ensuring high-quality and aligned data. 2. Off-Chain Dataset\ Conducting off-chain dataset, providing AI Agent services to perform more efficient AI operations. 3. Decentralized Consensus and Data Governance\ iDAO participates in the LazChain consensus in the form of a Quorum. Through the decentralization of multiple Quorum organizations, it ensures the reliability and transparency of data governance and storage. Each Quorum acts as an independent iDAO, similar to a traditional data center, but without storing data directly on-chain, effectively reducing on-chain storage costs. iDAO organizations achieve consensus to verify the trustworthiness of off-chain data, ensuring that data is efficiently and quickly available to both on-chain and off-chain agents while ensuring high availability and low latency.
# DAT Specifications & Flow LazAI’s Data Anchoring Token (DAT) is a semi-fungible token (SFT) standard designed for AI dataset anchoring, licensing, and AI model provenance tracking. This protocol introduces a multi-layered ownership model, ensuring composability, structured access control, and verifiable AI asset usage in a decentralized ecosystem.
LazAI’s Data Anchoring Token (DAT) protocol redefines AI dataset ownership, licensing, and provenance tracking by integrating semi-fungible tokenization, on-chain verification, and decentralized AI economy models. * **AI-Composable Economy:** Enables dataset/model composability for seamless AI evolution. * **Verifiable AI Assets:** Ensures trustless authentication through cryptographic proofs. * **Privacy-Preserving AI Training:** Supports ZK-protected AI model development. * **AI Data Exchange & Monetization:** Unlocks new AI business models, allowing transparent revenue sharing. This AI-first SFT standard establishes a scalable, trustless AI asset ecosystem, distinct from previous tokenization models. # Detailed Design of DAT The DAT protocol introduces a structured AI asset management system, leveraging on-chain metadata, off-chain data storage, and cryptographic proofs to ensure security, transparency, and usability. ### Core Data Structure of DAT Each DAT token instance consists of the following attributes:
AttributeTypeDescription
DAT IDuint256Unique identifier for the tokenized AI dataset or model.
Asset Typeenum { Dataset, Model, AI-Agent } Specifies whether the token represents a dataset, AI model, or an autonomous AI agent.
Slot ID (Category Tagging) uint256Defines the classification of AI assets, allowing datasets/models of the same category to be grouped for composability.
Partitioned Value (Token Units) uint256Represents divisible ownership or access quotas, enabling fractional AI asset ownership and licensing.
Access Control (Permissions) struct { readOnly, trainable, inferenceOnly, composable }Defines who can use the AI dataset/model and under what conditions.
Dataset Provenance Hashbytes32Hash of the dataset, anchoring off-chain data integrity (IPFS, Arweave, Filecoin).
Usage Statemapping (address => uint256)Tracks AI training/inference requests, ensuring proper usage-based payments.
Revenue Model mapping (address => uint256) Specifies how revenue is distributed among data contributors, model developers, and validators.
### AI Data Anchoring & Validation Mechanism The integrity and trustworthiness of AI datasets and models are secured through on-chain anchoring and decentralized verification mechanisms. * **Data Anchoring Process** * **Dataset Submission →** iDAO submits dataset metadata, cryptographic proofs (Merkle Tree, ZK Proofs), and storage references (IPFS, Arweave). * **Anchoring & Hashing →** A dataset fingerprint (hash) is generated and stored on-chain via DAT token metadata. * **Token Minting →** The system mints a DAT token representing the dataset, with predefined access rights, licensing conditions, and revenue-sharing logic. * **Decentralized Verification** * **Proof-of-Authenticity:** AI datasets and models require zero-knowledge proof (ZKP) verification, ensuring they were generated from valid sources. * **Fraud-Proof Mechanism:** Challengers can submit fraud proofs against datasets/models that violate integrity rules. If successfully disputed, the original submitter is slashed, and the challenger is rewarded. # DAT Token Lifecycle The LazAI AI Data Economy is built around programmable AI licensing, ownership trading, and dataset/model composability. #### Token Minting & Ownership Structure DAT tokens can be minted by AI data contributors, model creators, or AI agents via a structured issuance process: 1. **AI Data Submission:** The data provider submits dataset metadata to LazAI Flow. 2. **Validation & Anchoring:** The Quorum-based verification process confirms authenticity, generating a hashed dataset fingerprint. 3. **Token Minting:** The system mints a DAT token, encoding: Ownership rights, Usage-based pricing models, Access control permissions 4. **Revenue Distribution Rules:** The DAT contract automatically distributes revenue when datasets/models are used. #### AI Data & Model Exchange DAT supports AI dataset licensing and model trading through fractional ownership and dynamic pricing mechanisms.
FeatureImplementation
Fractional Ownership TradingUsers can sell or trade partial ownership of datasets without full asset transfer.
AI Model EvolutionDevelopers can fork datasets/models while ensuring original contributors retain revenue-sharing rights.
Permission-Based Dataset LicensingData owners set usage conditions (read-only, trainable, composable), enforced via on-chain access control.
Dynamic AI MarketplaceAI models and datasets are tokenized & exchanged as DAT, enabling seamless monetization of AI assets.
# Security, Privacy, & Trust **Cryptographic AI Asset Protection** * **ZK-Protected AI Data Usage:** Users can train AI models on encrypted datasets without direct access, ensuring privacy-preserving AI development. * **Merkle Proofs for Dataset Integrity:** All datasets include on-chain proofs of authenticity, preventing tampering or duplication. **Challenger-Based Fraud Detection** * **Challenger Model:** Any participant can challenge datasets/models with fraudulent claims. * **Slashing Mechanism:** If a dataset is found to be invalid or misleading, the submitter is penalized, and challengers are rewarded. # DAT Interaction Flow On-Chain & Off-Chain The following diagram illustrates the full lifecycle of a DAT token, from submission to verification, trading, and AI execution. 1. **iDAO Submits AI Data & Model (LazAI Flow):** Metadata, dataset hashes, and storage locations are submitted to LazAI Flow. 2. **Verification & Token Minting:** The LazChain network validates dataset integrity and mints the DAT token. 3. **AI Dataset/Model Usage:** Users request AI training/inference access, enforced via DAT-based smart contracts. 4. **Fraud-Proof Submission & Dispute Resolution:** Challengers can submit fraud proofs if AI models are biased or invalid. 5. **Revenue Distribution:** AI data/model owners receive royalty-based revenue upon each usage. LazAI’s Data Anchoring Token (DAT) protocol redefines AI dataset ownership, licensing, and provenance tracking by integrating semi-fungible tokenization, on-chain verification, and decentralized AI economy models. # Build your Digital Twin using LazAI Your Digital Twin is an AI persona that speaks in your voice. We generate it from your Twitter/X archive, store it in a portable Characterfile (character.json), and load it into an Alith agent that writes tweets for you (manually or on a schedule). ### Why a Digital Twin? * Portable persona: Single JSON file that any LLM agent can use * Separation of concerns: Keep *style/persona* in JSON; keep *logic* in code * Composable: Swap personas without touching the app ### Prerequisites * macOS/WSL/Linux with Node.js 18+ * An OpenAI or Anthropic (Claude) API key * A Twitter/X account + your archive .zip ### Step 0 — Clone the starter kit and install the dependencies ```bash git clone https://github.com/0xLazAI/Digital-Twin-Starter-kit.git cd Digital-Twin-Starter-kit ``` ### Step 1 — Generate your Characterfile from Tweets 1. Request your archive Get it from X/Twitter: Settings → Download an archive. 2. Run the generator ``` # You can run this anywhere; no cloning needed npx tweets2character ~/Downloads/twitter-YYYY-MM-DD-.zip ``` * Choose openai or claude * Paste your API key when prompted * Output: a character.json in the current directory
3. Move it into the Digital-Twin-Starter-kit Directrory Place character.json at your root (same level as index.js), e.g.: ``` /Digital-Twin-Starter-kit ├─ controller/ ├─ routes/ ├─ services/ ├─ character.json ← here └─ index.js ``` ### Step 2 — Feed character.json to an Alith Agent We create an Alith agent at runtime and pass your character as a preamble. This keeps persona separate from code and makes it hot‑swappable. * Loads character.json * Builds an Alith preamble from bio/lore/style * Generates a tweet in your voice * Provides postTweet (manual) and autoTweet (cron) helpers {% code overflow="wrap" %} ```javascript // controller/twitterController.js const { initializeTwitterClient } = require('../config/twitter'); const fs = require('fs'); const path = require('path'); // Load character data const characterData = JSON.parse( fs.readFileSync(path.join(__dirname, '../character.json'), 'utf8') ); // alith function with our character const alithfunction = async (username = "") => { try { const { Agent, LLM } = await import('alith'); const preamble = [ `You are ${characterData.name}.`, characterData.bio?.join(' ') || '', characterData.lore ? `Lore: ${characterData.lore.join(' ')}` : '', characterData.adjectives ? `Traits: ${characterData.adjectives.join(', ')}` : '', characterData.style?.post ? `Style for posts: ${characterData.style.post.join(' ')}` : '', ].filter(Boolean).join('\n'); const model = LLM.from_model_name(process.env.LLM_MODEL || 'gpt-4o-mini'); const agent = Agent.new('twitter_agent', model).preamble(preamble); const prompt = [ `Write one tweet in ${characterData.name}'s voice.`, username ? `Optionally greet @${username}.` : '', `<=240 chars, no code blocks, hashtags only if essential.` ].join(' '); const chat = agent.chat(); const result = await chat.user(prompt).complete(); const text = (result?.content || '').toString().trim(); if (!text) throw new Error('Empty tweet from agent'); return text.slice(0, 240); } catch (err) { // Fallback to examples if Alith/model is unavailable const examples = characterData.postExamples || []; const base = examples[Math.floor(Math.random() * examples.length)] || 'Hello from my agent!'; return username ? `${base} @${username}`.slice(0, 240) : base.slice(0, 240); } }; const generateQuirkyMessage = async (username) => { return await alithfunction(username); }; let twitterClient = null; // New function for cron job - posts tweet without requiring request/response const postTweetCron = async () => { try { console.log('Cron job: Starting tweet posting...'); // Initialize Twitter client if not already initialized if (!twitterClient) { console.log('Cron job: Initializing Twitter client...'); twitterClient = await initializeTwitterClient(); } // Generate message for cron job (you can customize this) const message = await generateQuirkyMessage('cron'); console.log('Cron job: Posting tweet with message:', message); // Send the tweet const tweetResult = await twitterClient.sendTweet(message); console.log('Cron job: Tweet result:', tweetResult); // Log success const tweetId = tweetResult.id || tweetResult.id_str; if (tweetId) { const tweetUrl = `https://twitter.com/${process.env.TWITTER_USERNAME}/status/${tweetId}`; console.log('Cron job: Tweet posted successfully:', tweetUrl); } else { console.log('Cron job: Tweet posted but no ID received'); } return { success: true, message: 'Tweet posted via cron job' }; } catch (error) { console.error('Cron job: Error in postTweetCron:', error); if (error.message.includes('authentication')) { twitterClient = null; } throw error; } }; const postTweet = async (req, res) => { console.log('Received request body:', req.body); try { const { username, address } = req.body; console.log('Processing username:', username); // Initialize Twitter client if not already initialized if (!twitterClient) { console.log('Initializing Twitter client...'); twitterClient = await initializeTwitterClient(); } // Remove @ symbol if included const cleanUsername = username.replace('@', ''); const message = await generateQuirkyMessage(cleanUsername); console.log('Posting tweet with message:', message); try { // Send the tweet const tweetResult = await twitterClient.sendTweet(message); console.log('Tweet result:', tweetResult); // Instead of fetching tweet details again, construct URL from the initial response // Most Twitter API responses include either an id or id_str field const tweetId = tweetResult.id || tweetResult.id_str; console.log(tweetId) if (!tweetId) { console.log('Tweet posted but no ID received:', tweetResult); return res.status(200).json({ success: true, message: 'Tweet posted successfully', tweetUrl: `https://twitter.com/${process.env.TWITTER_USERNAME}/`, // Fallback URL tweetText: message, updatedScore: 0 }); } const tweetUrl = `https://twitter.com/${process.env.TWITTER_USERNAME}/status/${tweetId}`; console.log('Constructed tweet URL:', tweetUrl); return res.status(200).json({ success: true, message: 'Tweet posted successfully', tweetUrl, tweetText: message, updatedScore: 0 }); } catch (tweetError) { console.error('Error with tweet operation:', tweetError); throw tweetError; } } catch (error) { console.error('Error in postTweet:', error); if (error.message.includes('authentication')) { twitterClient = null; } return res.status(500).json({ error: 'Failed to post tweet', details: error.message }); } }; module.exports = { postTweet, postTweetCron }; ``` {% endcode %} Environment ``` # .env TWITTER_USERNAME=username TWITTER_PASSWORD=password TWITTER_EMAIL=email # Alith / LLM LLM_MODEL=gpt-4o-mini ALITH_API_KEY=your_key_if_required # only if your Alith setup needs it ``` Install deps: ``` npm i alith node-cron # or pnpm add alith node-cron ``` ### Step 3 — Auto‑Tweet via Cron (uses your Digital Twin)
We schedule the agent to post automatically (e.g., at minute 5 every hour). services/cronService.js ```javascript const cron = require('node-cron'); const { postTweetCron } = require('../controller/twitterController'); class CronService { constructor() { this.isRunning = false; } start() { if (this.isRunning) { console.log('Cron service is already running'); return; } console.log('Starting cron service...'); // Schedule tweet posting every 1 minute cron.schedule('* * * * *', async () => { console.log('Cron job triggered: Posting tweet...'); try { await postTweetCron(); console.log('Tweet posted successfully via cron job'); } catch (error) { console.error('Error in cron job tweet posting:', error); } }, { scheduled: true, timezone: "UTC" }); this.isRunning = true; console.log('Cron service started successfully. Tweets will be posted every minute.'); } stop() { if (!this.isRunning) { console.log('Cron service is not running'); return; } console.log('Stopping cron service...'); cron.getTasks().forEach(task => task.stop()); this.isRunning = false; console.log('Cron service stopped'); } getStatus() { return { isRunning: this.isRunning, nextRun: this.isRunning ? 'Every minute' : 'Not scheduled' }; } } module.exports = CronService; ```
index.js (ESM) ```javascript import express from "express"; import cors from "cors"; import dotenv from 'dotenv'; dotenv.config(); import twitterRoutes from './routes/twitterRoutes.js'; import CronService from './services/cronService.js'; const app = express(); const cronService = new CronService(); app.use(cors({ origin: '*', // Allow all origins })); app.use(express.json()); app.use(express.urlencoded({ extended: true })); // Debug middleware to log requests app.use((req, res, next) => { console.log('Received request:', { method: req.method, path: req.path, body: req.body, headers: req.headers }); next(); }); app.use('/api', twitterRoutes); // Add cron status endpoint app.get('/api/cron/status', (req, res) => { const status = cronService.getStatus(); res.json(status); }); // Add cron control endpoints (optional - for manual control) app.post('/api/cron/start', (req, res) => { cronService.start(); res.json({ message: 'Cron service started' }); }); app.post('/api/cron/stop', (req, res) => { cronService.stop(); res.json({ message: 'Cron service stopped' }); }); // Error handling middleware app.use((err, req, res, next) => { console.error('Server error:', err); res.status(500).json({ error: 'Internal server error', details: err.message }); }); app.use(express.json({ limit: '10mb' })); app.use(express.urlencoded({ limit: '10mb', extended: true })); const port = process.env.PORT || 3005; app.listen(port, () => { console.log(`Server started on port ${port}`); // Start the cron service cronService.start(); }); ``` Route ```javascript // routes/twitterRoutes.js const express = require('express'); const router = express.Router(); const { postTweet } = require('../controller/twitterController'); router.post('/tweet', postTweet); module.exports = router; ``` Manual test ``` curl -X POST http://localhost:3000/tweet \ -H "Content-Type: application/json" \ -d '{"username":"someone"}' ``` ```bash npm run dev ``` ### Updating Your Twin * Re‑run npx tweets2character any time you want a fresh persona. * Replace character.json and restart your server. * The agent will immediately pick up the new style/preamble. ### Tips & Gotchas * CommonJS + ESM: Alith is ESM, your project is CJS → use dynamic import inside functions (shown above). * Length control: We trim to 240 chars to be safe with links/quoted tweets. * Fallbacks: If the model isn’t reachable, we fall back to postExamples from your character file. * Safety: Add your own guardrails (e.g., profanity, duplicates, rate limits) before posting. # Introduction ### LazAI API The LazAI API provides a simple way to run AI inference on private data without losing control of your information. It enables developers to perform context engineering, training, and evaluation directly on LazAI ensuring that data never leaves the owner’s control. Once you contribute your private data and mint a Data Anchoring Token (DAT), you can invoke AI models in a privacy-preserving way. This workflow guarantees that your sensitive data remains secure, auditable, and owned by you, while still powering intelligent AI services. *** ### Why Private Data Inference? Data privacy is essential in industries such as healthcare, finance, and research. Traditional AI services often require uploading datasets to centralized servers, increasing the risk of data exposure or misuse. With LazAI, inference happens securely on your own terms: * No data handover: Your dataset never leaves your control. * End-to-end encryption: All model calls and outputs are cryptographically secured. * Verifiable execution: Each inference request can be verified using on-chain proofs. * Ownership preserved: You retain ownership and monetization rights via the DAT standard. This allows you to build and run value-aligned AI agents that respect data sovereignty combining performance with full privacy compliance. *** ### Next Steps Continue with the following guides to learn how to use the LazAI API in different environments: * [Using Python](/private-data-inference/lazai-api/using-python) * [Using Node.js](/private-data-inference/lazai-api/using-nodejs) * [Using Rust](/private-data-inference/lazai-api/using-rust) # LazAI API ### Workflow Overview #### Contribute Data Complete the Data Contribution workflow and obtain your File ID after minting DAT.\ Checkout the below section to contribute your data. {% content-ref url="/pages/hnSMIbWKVYFMb76P3VTH" %} [Mint your DAT](/data-anchoring-token-dat/developer-implementation/mint-your-dat) {% endcontent-ref %} #### Run Inference Server Start a local or remote inference server that can process requests on your private data. #### Request Inference Use the LazAI client to send an inference request, referencing your File ID and providing settlement headers for secure access. # Using Python #### Best Practice: Use a Python Virtual Environment To avoid dependency conflicts and keep your environment clean, create and activate a Python virtual environment before installing any packages: ```bash python3 -m venv venvsource venv/bin/activate ``` #### Install Dependencies ```bash pip install llama-cpp-python pymilvus "pymilvus[model]" ``` #### Install Alith 
python3 -m pip install alith -U
#### Set Environment Variables For OpenAI/ChatGPT API: ```bash export PRIVATE_KEY= export OPENAI_API_KEY= ``` For other OpenAI-compatible APIs (DeepSeek, Gemini, etc.): ```bash export PRIVATE_KEY= export LLM_API_KEY= export LLM_BASE_URL= ``` #### Step 1: Run the Inference Server > **Note:** The public address of the private key you expose to the inference server is the `LAZAI_IDAO_ADDRESS`. Once the inference server is running, the URL must be registered using the `add_inference_node` function in Alith. This can only be done by LazAI admins. **Local Development** For OpenAI/ChatGPT API: ```python from alith.inference import run """Run the server and use the following command to test the server curl http://localhost:8000/v1/chat/completions \ -H "Content-Type: application/json" \ -H "X-LazAI-User: 0xc3e98E8A9aACFc9ff7578C2F3BA48CA4477Ecf49" \ -H "X-LazAI-Nonce: 123456" \ -H "X-LazAI-Signature: HSDGYUSDOWP123" \ -H "X-LazAI-Token-ID: 1" \ -d '{ "model": "gpt-3.5-turbo", "messages": [ {"role": "system", "content": "You are a helpful assistant"}, {"role": "user", "content": "What is the capital of France?"} ], "temperature": 0.7, "max_tokens": 100 }' """ server = run(model="gpt-3.5-turbo", settlement=True, engine_type="openai") ``` For other OpenAI-compatible APIs (DeepSeek, Gemini, etc.): ```python from alith.inference import run # Example: Using DeepSeek model from OpenRouter server = run(settlement=True, engine_type="openai", model="deepseek/deepseek-r1-0528") ``` **Production Deployment on Phala TEE Cloud** For production-ready applications, deploy your inference server on [Phala TEE Cloud ](https://docs.phala.network/phala-cloud/references/tee-cloud-cli) for enhanced security and privacy. Once deployed, you will receive an inference URL that needs to be registered using the `add_inference_node` function by LazAI admins. You can also use the existing inference nodes. #### Step 2: Request Inference via LazAI Client ```python from alith import Agent, LazAIClient # 1. Join the iDAO, register user wallet on LazAI and deposit fees (Only Once) LAZAI_IDAO_ADDRESS = "0xc3e98E8A9aACFc9ff7578C2F3BA48CA4477Ecf49" # Replace with your own address client = LazAIClient() try: client.get_user(client.wallet.address) print("User already exists") except Exception: print("User does not exist, adding user") client.add_user(10000000) client.deposit_inference(LAZAI_IDAO_ADDRESS, 1000000) # 2. Request the inference server with the settlement headers and DAT file id file_id = 11 # Use the File ID you received from the Data Contribution step url = client.get_inference_node(LAZAI_IDAO_ADDRESS)[1] print("url", url) agent = Agent( # Note: replace with your model here model="gpt-3.5-turbo", base_url=f"{url}/v1", # Extra headers for settlement and DAT file anchoring extra_headers=client.get_request_headers(LAZAI_IDAO_ADDRESS, file_id=file_id), ) print(agent.prompt("summarize it")) ``` *** ### Security & Privacy * **Your data never leaves your control.** Inference is performed in a privacy-preserving environment, using cryptographic settlement and secure computation. * **Settlement headers** ensure only authorized users and nodes can access your data for inference. * **File ID** links your inference request to the specific data you contributed, maintaining a verifiable chain of custody. # Using NodeJS #### Project Setup ```bash mkdir lazai-inference cd lazai-inference npm init -y ``` #### Install Alith ```bash npm i alith@latest ``` #### Create TypeScript Configuration Create a file named `tsconfig.json` with the following content: ```json { "compilerOptions": { "target": "ES2022", "module": "ESNext", "moduleResolution": "bundler", "allowSyntheticDefaultImports": true, "esModuleInterop": true, "allowJs": true, "strict": true, "skipLibCheck": true, "forceConsistentCasingInFileNames": true, "resolveJsonModule": true, "isolatedModules": true, "noEmit": true }, "ts-node": { "esm": true }, "include": ["*.ts"], "exclude": ["node_modules"] } ``` #### Set Environment Variables For OpenAI/ChatGPT API: ```bash export PRIVATE_KEY= export OPENAI_API_KEY= ``` For other OpenAI-compatible APIs (DeepSeek, Gemini, etc.): ```bash export PRIVATE_KEY= export LLM_API_KEY= export LLM_BASE_URL= ``` #### Step 1: Request Inference via LazAI Client Create a file named `app.ts` with the following content: ```typescript import { ChainConfig, Client } from "alith/lazai"; import { Agent } from "alith"; // Set up the private key for authentication process.env.PRIVATE_KEY = ""; const node = "0xc3e98E8A9aACFc9ff7578C2F3BA48CA4477Ecf49"; // Replace with your own inference node address const client = new Client(ChainConfig.testnet()); await client.getUser(client.getWallet().address); console.log( "The inference account of user is", await client.getInferenceAccount(client.getWallet().address, node) ); const fileId = 10; const nodeInfo = await client.getInferenceNode(node); const url = nodeInfo.url; const agent = new Agent({ // OpenAI-compatible inference server URL baseUrl: `${url}/v1`, model: "gpt-3.5-turbo", // Extra headers for settlement and DAT file anchoring extraHeaders: await client.getRequestHeaders(node, BigInt(fileId)), }); console.log(await agent.prompt("What is Alith?")); ``` #### Step 2: Run the Application ```bash npx tsx app.ts ``` # Using Rust #### Coming Soon Rust support for private data inference will be available in future releases. # LazAI Data Query # Using Python #### Best Practice: Use a Python Virtual Environment To avoid dependency conflicts and keep your environment clean, create and activate a Python virtual environment before installing any packages: ```bash python3 -m venv venv source venv/bin/activate ``` #### Install Dependencies ```bash pip install llama-cpp-python pymilvus "pymilvus[model]" ``` > For local development use the below installation command ```bash pip install llama-cpp-python pymilvus "pymilvus[milvus_lite]" ``` #### Install Alith 
python3 -m pip install alith -U
#### Set Environment Variables **Note:** The public address of the private key you expose to the Query server is the `LAZAI_IDAO_ADDRESS`. Once the query server is running, the URL must be registered using the `add_query_node` function in Alith. This can only be done by LazAI admins. > For local development ask LazAI admins to add your wallet address & "" url to register in Alith funciton. For OpenAI/ChatGPT API: ```bash export PRIVATE_KEY= export OPENAI_API_KEY= export RSA_PRIVATE_KEY_BASE64= ``` For other OpenAI-compatible APIs (DeepSeek, Gemini, etc.): ```bash export PRIVATE_KEY= export LLM_API_KEY= export LLM_BASE_URL= ``` #### Step 1: Run the Query Server **Local Development** For OpenAI API or OpenAI-compatible APIs (DeepSeek, Gemini, etc.): ```python import logging import sys import json import uvicorn import argparse from fastapi import FastAPI, Response, status from fastapi.middleware.cors import CORSMiddleware from alith.lazai import Client from alith.lazai.node.middleware import HeaderValidationMiddleware from alith.lazai.node.validator import decrypt_file_url from alith import MilvusStore, chunk_text from alith.query.types import QueryRequest from alith.query.settlement import QueryBillingMiddleware import os from dotenv import load_dotenv load_dotenv() # Get OpenAI API key from environment variable PRIVATE_KEY = os.getenv("PRIVATE_KEY") RSA_PRIVATE_KEY_BASE64 = os.getenv("RSA_PRIVATE_KEY_BASE64") # LLM_API_KEY = os.getenv("LLM_API_KEY") # LLM_BASE_URL = os.getenv("LLM_BASE_URL") # DSTACK_API_KEY = os.getenv("DSTACK_API_KEY") # Set the API key for OpenAI os.environ["PRIVATE_KEY"] = PRIVATE_KEY os.environ["RSA_PRIVATE_KEY_BASE64"] = RSA_PRIVATE_KEY_BASE64 # os.environ["LLM_API_KEY"] = LLM_API_KEY # os.environ["LLM_BASE_URL"] = LLM_BASE_URL # os.environ["DSTACK_API_KEY"] = DSTACK_API_KEY # Logging configuration logging.basicConfig( stream=sys.stdout, level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s", ) logger = logging.getLogger(__name__) client = Client() app = FastAPI(title="Alith LazAI Privacy Data Query Node", version="1.0.0") store = MilvusStore() collection_prefix = "query_" @app.get("/health") async def health_check(): return {"status": "healthy", "message": "Server is running"} @app.get("/") async def root(): return {"message": "Alith LazAI Privacy Data Query Node", "version": "1.0.0"} @app.post("/query/rag") async def query_rag(req: QueryRequest): try: file_id = req.file_id if req.file_url: file_id = client.get_file_id_by_url(req.file_url) if file_id: file = client.get_file(file_id) else: return Response( status_code=status.HTTP_400_BAD_REQUEST, content=json.dumps( { "error": { "message": "File ID or URL is required", "type": "invalid_request_error", } } ), ) owner, file_url, file_hash = file[1], file[2], file[3] collection_name = collection_prefix + file_hash # Cache data in the vector database if not store.has_collection(collection_name): encryption_key = client.get_file_permission( file_id, client.contract_config.data_registry_address ) data = decrypt_file_url(file_url, encryption_key).decode("utf-8") store.create_collection(collection_name=collection_name) store.save_docs(chunk_text(data), collection_name=collection_name) data = store.search_in( req.query, limit=req.limit, collection_name=collection_name ) logger.info(f"Successfully processed request for file: {file}") return { "data": data, "owner": owner, "file_id": file_id, "file_url": file_url, "file_hash": file_hash, } except Exception as e: return Response( status_code=status.HTTP_500_INTERNAL_SERVER_ERROR, content=json.dumps( { "error": { "message": f"Error processing request for req: {req}. Error: {str(e)}", "type": "internal_error", } } ), ) def run(host: str = "0.0.0.0", port: int = 8000, *, settlement: bool = False): # FastAPI app and LazAI client initialization app.add_middleware( CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"], ) if settlement: app.add_middleware(HeaderValidationMiddleware) app.add_middleware(QueryBillingMiddleware) return uvicorn.run(app, host=host, port=port) if __name__ == "__main__": description = "Alith data query server. Host your own embedding models and support language query!" parser = argparse.ArgumentParser(description=description) parser.add_argument( "--host", type=str, help="Server host", default="0.0.0.0", ) parser.add_argument( "--port", type=int, help="Server port", default=8000, ) parser.add_argument( "--model", type=str, help="Model name or path", default="/root/models/qwen2.5-1.5b-instruct-q5_k_m.gguf", ) args = parser.parse_args() run(host=args.host, port=args.port, settlement=False) ``` **Production Deployment on Phala TEE Cloud** For production-ready applications, deploy your data query server on [Phala TEE Cloud ](https://docs.phala.network/phala-cloud/references/tee-cloud-cli) for enhanced security and privacy. Once deployed, you will receive an data query URL that needs to be registered using the `add_query_node` function by LazAI admins.\ \ Use this starter kit to create and push your Docker image\ You can also use the existing data query nodes. #### Step 2: Request Query via LazAI Client ```python from alith.lazai import Client import requests client = Client() node = "0x2591E4C0e6E771927A45eFAE8Cd5Bf20e585A57A" #change this address with one you registered with admin try: print("try to get user") user = client.get_user(client.wallet.address) print(user) except Exception as e: print("try to get user failed") print(e) print("try to add user failed") client.add_user(1000000) print("user added") print("try to get query account") url = client.get_query_node(node)[1] print(url) headers = client.get_request_headers(node) print("request headers:", headers) print( "request result:", requests.post( f"{url}/query/rag", headers=headers, json={ "file_id": 10, #change with your file_id "query": "summarise the best character?", }, ).json(), ) ``` *** ### Security & Privacy * **Your data never leaves your control.** Data query is performed in a privacy-preserving environment, using cryptographic settlement and secure computation. * **Settlement headers** ensure only authorized users and nodes can access your data for data query. * **File ID** links your data query request to the specific data you contributed, maintaining a verifiable chain of custody. # Overview This guide will walk you through everything you need to get started with Alith. Whether you’re building intelligent agents, integrating tools, or experimenting with language models, Alith provides a seamless experience across multiple programming languages. Below, you’ll find installation instructions, quick start guides, and examples for Rust, Python, and Node.js. ### Install Dependency {% tabs %} {% tab title="Alith dependency" %} ```sh npm install alith # Or use pnpm pnpm install alith # Or use yarn yarn install alith ``` {% endtab %} {% tab title="json-schema dependency" %} ```sh npm i --save-dev @types/json-schema # Or use pnpm pnpm install --save-dev @types/json-schema # Or use yarn yarn install --save-dev @types/json-schema ``` {% endtab %} {% endtabs %} ### Write the Code {% code overflow="wrap" %} ```javascript import { Agent } from "alith"; const agent = new Agent({ model: "gpt-4", preamble: "You are a comedian here to entertain the user using humour and jokes.", }); console.log(await agent.prompt("Entertain me!")); ``` {% endcode %} #### Model Provider Settings To configure different AI model providers, here we use the OpenAI model as an example. **Unix** ```sh export OPENAI_API_KEY= ``` **Windows** ```powershell $env:OPENAI_API_KEY = "" ``` ### Run the Code ```sh tsc index.ts && node index.js ``` # Build Your Twitter Agent ## Creating a Twitter Agent with Alith In this tutorial, you will learn how to create a Node.js application that integrates X/Twitter with Alith’s Model Context Protocol (MCP) feature. This allows you to use LLM models and agents to fetch tweets from a specific user, post a new tweet, like a tweet, quote a tweet, etc. *Note: Although we used Node.js in this tutorial, you can still use Alith Rust SDK and Python SDK to complete this Twitter agent.* Get Started ### Prerequisites Before starting, ensure you have the following: * **OpenAI API Key:** Sign up at OpenAI and get your API key or use your favorite LLM models. * **Node.js 18+ environment and pnpm.** * **A X/Twitter account.** ### Install Required Libraries Initialize the project and install the necessary Node.js libraries using pnpm: ```bash mkdir alith-twitter-example && cd alith-twitter-example && pnpm init pnpm i alith pnpm i --save-dev @types/json-schema ``` ### Set Up Environment Variables #### LLM API Key Store your API keys and tokens as environment variables for security: ```bash export OPENAI_API_KEY="your-openai-api-key" ``` #### Cookie Authentication ```bash export AUTH_METHOD=cookies export TWITTER_COOKIES=["auth_token=your_auth_token; Domain=.twitter.com", "ct0=your_ct0_value; Domain=.twitter.com"] ``` **To obtain cookies:** 1. Log in to Twitter in your browser. 2. Open Developer Tools (F12). 3. Go to the Application tab > Cookies. 4. Copy the values of auth\_token and ct0 cookies. #### Username/Password Authentication ```bash export AUTH_METHOD=credentials export TWITTER_USERNAME=your_username export TWITTER_PASSWORD=your_password export TWITTER_EMAIL=your_email@example.com # Optional export TWITTER_2FA_SECRET=your_2fa_secret # Optional, required if 2FA is enabled ``` #### API Authentication ```bash export AUTH_METHOD=api export TWITTER_API_KEY=your_api_key export TWITTER_API_SECRET_KEY=your_api_secret_key export TWITTER_ACCESS_TOKEN=your_access_token export TWITTER_ACCESS_TOKEN_SECRET=your_access_token_secret ``` ### Write the Typescript Code Create a Typescript script (e.g., index.ts) and add the following code: *Note: We need to install `tsc` firstly.* ```typescript import { Agent } from "alith"; const agent = new Agent({ name: "A twitter agent", model: "gpt-4", preamble: "You are a automatic twitter agent.", mcpConfigPath: "mcp_twitter.json", }); console.log(await agent.prompt("Search Twitter for tweets about AI")); console.log(await agent.prompt('Post a tweet saying "Hello from Alith Twitter Agent!"')); console.log(await agent.prompt("Get the latest tweets from @OpenAI")); console.log(await agent.prompt("Chat with Grok about quantum computing")); ``` ### Write the MCP Config Create a JSON file named `mcp_twitter.json` and add the following code: ```json { "mcpServers": { "agent-twitter-client-mcp": { "command": "npx", "args": ["-y", "agent-twitter-client-mcp"], "env": { "AUTH_METHOD": "cookies", "TWITTER_COOKIES": "[\"auth_token=YOUR_AUTH_TOKEN; Domain=.twitter.com\", \"ct0=YOUR_CT0_VALUE; Domain=.twitter.com\", \"twid=u%3DYOUR_USER_ID; Domain=.twitter.com\"]" } } } } ``` ### Run the Application Run your Typescript script to start and test the application: ```bash npx tsc && node index.js ``` # Build Your On-Chain AI Agent Complete Step-by-Step Tutorial: On-chain AI Agent This comprehensive tutorial will guide you through building an AI Agent that can handle both general conversations and blockchain operations, specifically token balance checking on the LazAI testnet. ### Prerequisites Before starting, ensure you have: * **Node.js 18+** installed * **npm or yarn** package manager * **Basic knowledge** of React, TypeScript, and Next.js * **OpenAI API key** (for AI conversations) * **Code editor** (VS Code recommended) ### Project Setup #### Step 1: Create Next.js Project ```bash # Create a new Next.js project with TypeScript npx create-next-app@latest ai-agent --typescript --tailwind --eslint --app --src-dir=false --import-alias="@/*" # Navigate to the project directory cd ai-agent ``` #### Step 2: Verify Project Structure Your project should look like this: ``` ai-blockchain-chatbot/ ├── app/ │ ├── globals.css │ ├── layout.tsx │ └── page.tsx ├── public/ ├── next.config.ts ├── package.json └── tsconfig.json ``` ### Dependencies Installation #### Step 3: Install Required Packages ```bash # Install core dependencies npm install ethers alith # Install development dependencies npm install --save-dev node-loader ``` **What each package does:** * `ethers`: Ethereum library for blockchain interactions * `alith`: AI SDK for OpenAI integration * `node-loader`: Webpack loader for native modules ### Next.js Configuration #### Step 4: Configure next.config.ts Create or update `next.config.ts`: ```typescript import type { NextConfig } from "next"; const nextConfig: NextConfig = { webpack: (config, { isServer }) => { if (isServer) { // On the server side, handle native modules config.externals = config.externals || []; config.externals.push({ '@lazai-labs/alith-darwin-arm64': 'commonjs @lazai-labs/alith-darwin-arm64', }); } else { // On the client side, don't bundle native modules config.resolve.fallback = { ...config.resolve.fallback, '@lazai-labs/alith-darwin-arm64': false, 'alith': false, }; } return config; }, // Mark packages as external for server components serverExternalPackages: ['@lazai-labs/alith-darwin-arm64', 'alith'], }; export default nextConfig; ``` **Why this configuration is needed:** * Handles native modules that can't be bundled by webpack * Prevents client-side bundling of server-only packages * Ensures proper module resolution ### Token Balance API #### Step 5: Create API Directory Structure ```bash # Create the API directories mkdir -p app/api/token-balance mkdir -p app/api/chat mkdir -p app/components ``` #### Step 6: Create Token Balance API Create `app/api/token-balance/route.ts`: ```typescript import { NextRequest, NextResponse } from 'next/server'; import { ethers } from 'ethers'; // ERC-20 Token ABI (minimal for balance checking) const ERC20_ABI = [ { "constant": true, "inputs": [{"name": "_owner", "type": "address"}], "name": "balanceOf", "outputs": [{"name": "balance", "type": "uint256"}], "type": "function" }, { "constant": true, "inputs": [], "name": "decimals", "outputs": [{"name": "", "type": "uint8"}], "type": "function" }, { "constant": true, "inputs": [], "name": "symbol", "outputs": [{"name": "", "type": "string"}], "type": "function" }, { "constant": true, "inputs": [], "name": "name", "outputs": [{"name": "", "type": "string"}], "type": "function" } ]; // LazAI Testnet configuration const LAZAI_RPC = 'https://testnet.lazai.network'; const LAZAI_CHAIN_ID = 133718; export async function POST(request: NextRequest) { try { const { contractAddress, walletAddress } = await request.json(); // Validate inputs if (!contractAddress || !walletAddress) { return NextResponse.json( { error: 'Contract address and wallet address are required' }, { status: 400 } ); } // Validate Ethereum addresses if (!ethers.isAddress(contractAddress)) { return NextResponse.json( { error: 'Invalid contract address format' }, { status: 400 } ); } if (!ethers.isAddress(walletAddress)) { return NextResponse.json( { error: 'Invalid wallet address format' }, { status: 400 } ); } // Connect to LazAI testnet const provider = new ethers.JsonRpcProvider(LAZAI_RPC); // Create contract instance const contract = new ethers.Contract(contractAddress, ERC20_ABI, provider); try { // Get token information with individual error handling let balance, decimals, symbol, name; try { balance = await contract.balanceOf(walletAddress); } catch (error) { return NextResponse.json( { error: 'Failed to get token balance. Contract might not be a valid ERC-20 token.' }, { status: 400 } ); } try { decimals = await contract.decimals(); } catch (error) { // If decimals call fails, assume 18 decimals (most common) decimals = 18; } try { symbol = await contract.symbol(); } catch (error) { symbol = 'UNKNOWN'; } try { name = await contract.name(); } catch (error) { name = 'Unknown Token'; } // Format balance - convert BigInt to string first const formattedBalance = ethers.formatUnits(balance.toString(), decimals); // Get LAZAI balance for comparison const lazaiBalance = await provider.getBalance(walletAddress); const formattedLazaiBalance = ethers.formatEther(lazaiBalance.toString()); return NextResponse.json({ success: true, data: { tokenName: name, tokenSymbol: symbol, contractAddress: contractAddress, walletAddress: walletAddress, balance: formattedBalance, rawBalance: balance.toString(), // Convert BigInt to string decimals: Number(decimals), // Convert BigInt to number lazaiBalance: formattedLazaiBalance, network: { name: 'LazAI Testnet', chainId: LAZAI_CHAIN_ID, rpc: LAZAI_RPC, explorer: 'https://testnet-explorer.lazai.network' } } }); } catch (contractError) { console.error('Contract interaction error:', contractError); return NextResponse.json( { error: 'Contract not found or not a valid ERC-20 token on LazAI testnet' }, { status: 400 } ); } } catch (error) { console.error('Error checking token balance:', error); // Handle specific errors if (error instanceof Error) { if (error.message.includes('execution reverted')) { return NextResponse.json( { error: 'Contract not found or not a valid ERC-20 token' }, { status: 400 } ); } if (error.message.includes('network') || error.message.includes('connection')) { return NextResponse.json( { error: 'Network connection failed. Please try again.' }, { status: 500 } ); } } return NextResponse.json( { error: 'Failed to check token balance' }, { status: 500 } ); } } ``` **Key Features:** * Validates Ethereum addresses * Handles BigInt serialization * Provides fallback values for missing token data * Comprehensive error handling * Returns both token and native currency balances #### Step 7: Create Smart Chat API Create `app/api/chat/route.ts`: ```typescript import { NextRequest, NextResponse } from 'next/server'; import { Agent } from 'alith'; // Function to detect token balance requests function isTokenBalanceRequest(message: string): { isRequest: boolean; contractAddress?: string; walletAddress?: string } { const lowerMessage = message.toLowerCase(); // Check for common patterns const balancePatterns = [ /check.*balance/i, /token.*balance/i, /balance.*check/i, /how much.*token/i, /token.*amount/i ]; const hasBalanceIntent = balancePatterns.some(pattern => pattern.test(lowerMessage)); if (!hasBalanceIntent) { return { isRequest: false }; } // Extract Ethereum addresses (basic pattern) const addressPattern = /0x[a-fA-F0-9]{40}/g; const addresses = message.match(addressPattern); if (!addresses || addresses.length < 2) { return { isRequest: false }; } // Assume first address is contract, second is wallet return { isRequest: true, contractAddress: addresses[0], walletAddress: addresses[1] }; } export async function POST(request: NextRequest) { try { const { message } = await request.json(); if (!message || typeof message !== 'string') { return NextResponse.json( { error: 'Message is required and must be a string' }, { status: 400 } ); } // Check if this is a token balance request const balanceRequest = isTokenBalanceRequest(message); if (balanceRequest.isRequest && balanceRequest.contractAddress && balanceRequest.walletAddress) { // Route to token balance API try { const balanceResponse = await fetch(`${request.nextUrl.origin}/api/token-balance`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ contractAddress: balanceRequest.contractAddress, walletAddress: balanceRequest.walletAddress }), }); const balanceData = await balanceResponse.json(); if (balanceData.success) { const formattedResponse = `🔍 **Token Balance Check Results** **Token Information:** • Name: ${balanceData.data.tokenName} • Symbol: ${balanceData.data.tokenSymbol} • Contract: \`${balanceData.data.contractAddress}\` **Wallet Information:** • Address: \`${balanceData.data.walletAddress}\` • Token Balance: **${balanceData.data.balance} ${balanceData.data.tokenSymbol}** • LAZAI Balance: **${balanceData.data.lazaiBalance} LAZAI** **Network:** ${balanceData.data.network.name} (Chain ID: ${balanceData.data.network.chainId}) You can view this transaction on the [block explorer](${balanceData.data.network.explorer}/address/${balanceData.data.walletAddress}).`; return NextResponse.json({ response: formattedResponse }); } else { let errorMessage = `❌ **Error checking token balance:** ${balanceData.error}`; // Provide helpful suggestions based on the error if (balanceData.error.includes('not a valid ERC-20 token')) { errorMessage += `\n\n💡 **Suggestions:** • Make sure the contract address is a valid ERC-20 token on LazAI testnet • Verify the contract exists and is deployed on the network • Check if the contract implements the standard ERC-20 interface`; } else if (balanceData.error.includes('Invalid contract address')) { errorMessage += `\n\n💡 **Suggestion:** Please provide a valid Ethereum address starting with 0x followed by 40 hexadecimal characters.`; } else if (balanceData.error.includes('Invalid wallet address')) { errorMessage += `\n\n💡 **Suggestion:** Please provide a valid Ethereum wallet address starting with 0x followed by 40 hexadecimal characters.`; } return NextResponse.json({ response: errorMessage }); } } catch (error) { console.error('Error calling token balance API:', error); return NextResponse.json({ response: "❌ **Error:** Failed to check token balance. Please try again later.\n\n💡 **Possible causes:**\n• Network connection issues\n• Invalid contract or wallet addresses\n• Contract not deployed on LazAI testnet" }); } } // Check if API key is configured for AI responses if (!process.env.OPENAI_API_KEY) { return NextResponse.json( { error: 'OpenAI API key is not configured' }, { status: 500 } ); } // Initialize the Alith agent with enhanced preamble const agent = new Agent({ model: "gpt-4", preamble: `Your name is Alith. You are a helpful AI assistant with blockchain capabilities. **Available Features:** 1. **Token Balance Checker**: Users can check ERC-20 token balances on the LazAI testnet by providing a contract address and wallet address. The format should include both addresses in the message. **Network Information:** - Network: LazAI Testnet - Chain ID: 133718 - RPC: https://testnet.lazai.network - Explorer: https://testnet-explorer.lazai.network **How to use token balance checker:** Users can ask questions like: - "Check token balance for contract 0x... and wallet 0x..." - "What's the balance of token 0x... in wallet 0x..." - "Check balance: contract 0x... wallet 0x..." Provide clear, concise, and accurate responses. Be friendly and engaging in your conversations. If users ask about token balances, guide them to provide both contract and wallet addresses.`, }); // Get response from the agent const response = await agent.prompt(message); return NextResponse.json({ response }); } catch (error) { console.error('Error in chat API:', error); return NextResponse.json( { error: 'Failed to get response from AI' }, { status: 500 } ); } } ``` **Key Features:** * Smart message routing based on content analysis * Pattern recognition for balance requests * Automatic address extraction * Enhanced AI prompts with blockchain context * Comprehensive error handling ### Chat Interface Component #### Step 8: Create Chat Interface Create `app/components/ChatInterface.tsx`: ```typescript 'use client'; import { useState, useRef, useEffect } from 'react'; interface Message { id: string; content: string; role: 'user' | 'assistant'; timestamp: Date; } // Simple markdown renderer for basic formatting const renderMarkdown = (text: string) => { return text .replace(/\*\*(.*?)\*\*/g, '$1') .replace(/\*(.*?)\*/g, '$1') .replace(/`(.*?)`/g, '$1') .replace(/\n/g, '
') .replace(/•/g, '•'); }; export default function ChatInterface() { const [messages, setMessages] = useState([]); const [inputMessage, setInputMessage] = useState(''); const [isLoading, setIsLoading] = useState(false); const messagesEndRef = useRef(null); useEffect(() => { // Auto-scroll to bottom when new messages are added messagesEndRef.current?.scrollIntoView({ behavior: 'smooth' }); }, [messages]); const handleSendMessage = async () => { if (!inputMessage.trim() || isLoading) return; const userMessage: Message = { id: Date.now().toString(), content: inputMessage.trim(), role: 'user', timestamp: new Date(), }; setMessages(prev => [...prev, userMessage]); setInputMessage(''); setIsLoading(true); try { const response = await fetch('/api/chat', { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ message: inputMessage.trim() }), }); if (!response.ok) { throw new Error('Failed to get response'); } const data = await response.json(); if (data.error) { throw new Error(data.error); } const assistantMessage: Message = { id: (Date.now() + 1).toString(), content: data.response, role: 'assistant', timestamp: new Date(), }; setMessages(prev => [...prev, assistantMessage]); } catch (error) { console.error('Error getting response:', error); const errorMessage: Message = { id: (Date.now() + 1).toString(), content: 'Sorry, I encountered an error. Please try again.', role: 'assistant', timestamp: new Date(), }; setMessages(prev => [...prev, errorMessage]); } finally { setIsLoading(false); } }; const handleKeyPress = (e: React.KeyboardEvent) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); handleSendMessage(); } }; const formatTime = (date: Date) => { return date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }); }; return (
{/* Header */}

Alith AI Assistant

Powered by Alith SDK & ChatGPT • Blockchain Capabilities

{/* Messages Container */}
{messages.length === 0 && (
🤖

Welcome to Alith AI!

I can help you with general questions and blockchain operations.

{/* Feature showcase */}

Available Features:

  • • 💬 General AI conversations
  • • 🔍 Token balance checking on LazAI testnet
  • • 📊 Blockchain data queries
Example: "Check token balance for contract 0x1234... and wallet 0x5678..."
)} {messages.map((message) => (
{formatTime(message.timestamp)}
))} {isLoading && (
Alith is thinking...
)}
{/* Input Container */}