# Kite Developer Docs > Kite is agentic payment infrastructure. Kite Agent Passport gives AI agents identity, delegated payment authority, and onchain settlement. ## Endpoints - Sharded full content (per collection): - https://docs.gokite.ai/llms/docs.txt - https://docs.gokite.ai/llms/changelog.txt - https://docs.gokite.ai/llms/api-reference.txt - https://docs.gokite.ai/llms/blog.txt - Full corpus (capped at 2 MiB): https://docs.gokite.ai/llms-full.txt - MCP server (read-only): https://docs.gokite.ai/mcp - Sitemap: https://docs.gokite.ai/sitemap.xml --- # Give your AI agent a wallet you control URL: https://docs.gokite.ai/ Kite Agent Passport lets autonomous AI agents pay for services on your behalf — with their own identity, a funded wallet, spending rules you set, and a verifiable record of everything they do. ## Start here My agent pays for things} href="/passport/payments" description={Install Passport, approve a spending session with your passkey, and your agent can pay for services on your behalf.} /> I sell to agents} href="/passport/seller" description={Accept payments from AI agents for your API or service, with x402 or MPP.} /> I build on Kite Chain} href="/kite-chain/1-getting-started/network-information" description={Network endpoints, block explorers, and how to connect your app to Kite Chain.} /> [Install the kpass CLI →](/passport/install) [View the changelog →](/changelog) --- # Architecture & Design Pillars URL: https://docs.gokite.ai/about/architecture-and-design-pillars Kite is built from first principles for autonomous agents, not adapted from human-centric systems. Every architectural decision optimizes for one goal: enabling agents to operate with mathematical safety guarantees. ## Architecture Overview ### Four-Layer Architecture Kite implements a four-layer architecture that separates concerns while maintaining security and performance: ![](/images/get-started/architecture-and-design-pillars/image-3-.png) ### Base Layer: EVM-Compatible L1 Optimized specifically for agent transaction patterns: * **Stablecoin-native fees**: Predictable costs in USDC/pyUSD, eliminating gas token volatility * **State channels for micropayments**: $0.000001 per message with instant settlement * **Dedicated payment lanes**: Isolated blockspace preventing congestion * **Agent transaction types**: Not just payments, but computation requests and API calls embedded in transactions ### Platform Layer: Agent-Ready APIs Abstracts blockchain complexity for developers: * **Identity management**: Hierarchical wallets with BIP-32 derivation * **Authorization APIs**: Session key generation and management * **Payment processing**: State channel opening, signing, and settlement * **SLA enforcement**: Automatic penalty and reward execution ### Programmable Trust Layer Novel primitives that enable trustless agent operations: * **Kite Passport**: Cryptographic agent IDs with selective disclosure * **x402 Protocol:** Standardized rail for agent-to-agent intents, enabling verifiable message passing, escrowed execution, and settlement across ecosystems * **Agent SLAs**: Smart contract interaction templates with enforced guarantees * **Protocol bridges**: Compatibility with A2A, MCP, OAuth 2.1, and AP2 * **Reputation system**: Verifiable behavioral history portable across services ### Ecosystem Layer Two interconnected marketplaces: * **Application marketplace**: AI services registered once, discoverable by millions of agents * **Agent ecosystem**: Agents coordinate through standard protocols * **Service discovery**: Cryptographic capability attestations enable trustless matching * **Reputation networks**: Global trust scores based on verifiable performance _For detailed architectural components and terminology, see_ [_Core Concepts & Terminology_](core-concepts-and-terminology) ## Design Principles ### 1. Agent-First Architecture Traditional blockchains assume human users who can manage keys and evaluate risks. Kite breaks this assumption entirely: * **Hierarchical Identity**: User → Agent → Session with cryptographic delegation * **Programmable Constraints**: Smart contracts enforce spending limits and operational boundaries that agents cannot exceed * **Session-Based Security**: Ephemeral keys for individual operations, not permanent credentials * **Agent Transaction Types**: Embedded API requests within payments, not just value transfers ### 2. Cryptographic Trust Chain Every action creates verifiable audit trails: * **No Direct Key Access**: Agents never touch private keys directly * **Fine-Grained Authorization**: Task-level permissions, not agent-level * **Reputation Without Identity Leakage**: Shared reputation with independent identity ### 3. Sovereignty Through Separation * **Decentralized Assets**: Self-custodial wallets with smart contract enforcement * **Centralized Services**: Platform APIs for developer experience * **Best of Both**: Security of decentralization + usability of centralization ### 4. Native Protocol Compatibility Rather than creating another isolated protocol, Kite embraces existing standards as first principles: * **A2A Protocol**: Direct agent coordination across platforms * **Agent Payment Protocol (AP2)**: Kite executes AP2 intents with on-chain enforcement * **MCP**: Model interoperability across the entire LLM ecosystem * **OAuth 2.1**: Backward compatibility with existing services * **X402 Standard**: Agent-native payments for future developments ### 5. Mathematical Safety Guarantees * **Provable Bounds**: Users know exact maximum exposure before authorizing agents * **Cryptographic Enforcement**: Constraints cannot be violated even with total agent compromise * **Automatic Expiration**: All authorizations include time-based revocation * **Defense in Depth**: Multiple security layers with graduated impact ### 6. Economic Viability for Micropayments * **Sub-cent Transactions**: Enable per-message, per-token, per-request pricing * **Predictable Costs**: Stablecoin fees eliminate gas token volatility * **Instant Settlement**: Real-time value transfer without waiting periods * **Global Interoperability**: Borderless payments without currency conversion *** _For detailed concepts and terminology, see_ [_Core Concepts & Terminology_](core-concepts-and-terminology) --- # Core Concepts & Terminology URL: https://docs.gokite.ai/about/core-concepts-and-terminology Essential building blocks that enable autonomous agent operations in Kite's ecosystem. ## Core Entities ### User Human principal who owns and controls AI agents: - Manages master wallets (root of cryptographic trust) - Delegates capabilities while maintaining ultimate authority - Sets global policies that cascade through all agents - Remains legally responsible for agent actions ### Agent Autonomous program acting on behalf of a user: - Executes complex tasks across multiple services - Handles real money within cryptographically enforced boundaries - Maintains own wallet and reputation - Bound to user through BIP-32 derivation ### Service External offerings that agents interact with: - Data APIs, GPU providers, SaaS applications - Integrate via MCP, A2A, or OAuth protocols - Maintain sovereignty over access policies ### Merchant/Provider Business operators who make services discoverable: - Define SLAs with automatic penalties - Establish reputation through verifiable performance - Transform B2B services into plug-and-play agent resources ## Identity & Trust Infrastructure ### Kite Passport Cryptographic identity card that: - Creates complete trust chain from user to agent to action - Binds to existing identities (Gmail, Twitter) via cryptographic proofs - Contains capabilities: spending limits, service access - Enables selective disclosure (prove ownership without revealing identity) ### Decentralized Identifier (DID) Globally unique, cryptographically verifiable identifiers: - User: `did:kite:alice.eth` - Agent: `did:kite:alice.eth/chatgpt/portfolio-manager-v1` - Makes authority chains instantly verifiable ### Verifiable Credentials (VCs) Cryptographically signed attestations proving: - Compliance training completion - Trading licenses - Reputation thresholds - Enable fine-grained access control ### Proof of AI Immutable, tamper-evident logs anchored to blockchain: - Complete lineage from user authorization to final outcome - Indisputable evidence for disputes - Full transparency for regulators ## Wallet Architecture ### EOA Wallet (Externally Owned Account) Traditional blockchain wallet controlled by private key: - **Root of authority** in Kite's architecture - Lives in secure enclaves, hardware security modules, or protected device storage - **Never exposed** to agents, services, or the Kite platform itself - Signs initial authorizations that delegate specific powers to agent operations - Users maintain ultimate control with ability to instantly revoke all delegated permissions ### AA Wallet (Smart Contract Account) Programmable accounts with built-in logic enabling revolutionary agent payment capabilities: **Account Abstraction Features**: - Write smart contract code that governs spending - Bundle transaction execution for efficiency - Allow third parties to pay gas fees (gasless transactions) - Interact with multiple accounts simultaneously - Perform cross-program communications - Integrate customized logic for complex workflows **Unified Account Model**: - User owns a **single on-chain AA account** holding shared funds in stablecoins - Multiple agents (Claude, ChatGPT, Cursor) operate this account via their own session keys - Each agent operates only within its authorized limits enforced by smart contracts - Result: One treasury, per-session risk isolation, fine-grained auditable control - No fund fragmentation, no complex reconciliation, elegant unified management **Implementation**: ```javascript addSessionKeyRule( address sessionKeyAddress, // Newly generated session key bytes32 agentId, // Agent performing the actions bytes4 functionSelector, // Allowed function (e.g., pay()) uint256 valueLimit // Maximum transaction value ) ``` ### Embedded Wallets Self-custodial wallets integrated directly into applications: - Users don't manage seed phrases or private keys, yet maintain complete control - **One-click agent authorization** and automatic session management - Transparent fund flows - users think in dollars, not tokens - Makes blockchain invisible while preserving cryptographic guarantees ### Agent Payment Protocol Comprehensive system enabling payment flows impossible with traditional infrastructure: **Capabilities**: - **Micropayments**: Down to fractions of cents ($0.000001 per message) - **Streaming payments**: Flow continuously based on usage (per-second, per-token) - **Pay-per-inference models**: Every API call carries value - **Conditional payments**: Release based on performance verification - **Instant settlement**: No waiting periods, real-time value transfer - **Global reach**: Borderless payments without currency conversion **Integration**: - Programmatic commerce where every interaction becomes a micropayment - Works seamlessly with state channels for off-chain efficiency - Supports both on-chain and off-chain settlement patterns ### On/Off-Ramp API The bridge between traditional finance and the agent economy: **Capabilities**: - Integration with providers like PayPal and banking partners - Users fund agent wallets with credit cards - Merchants withdraw earnings to bank accounts - Handles compliance, fraud prevention, and currency conversion invisibly **User Experience**: - Users never need to understand blockchain - Think in dollars in and dollars out - Makes agent payments accessible to billions who will never own crypto ## Governance & Safety ### SLA (Service-Level Agreement) Contracts Smart contracts that transform vague service promises into mathematically enforced guarantees: **Unlike Traditional SLAs** (legal enforcement, manual claims): Kite SLAs **automatically execute** penalties and rewards through smart contract code. **Example Guarantees**: - **Response time**: <100ms with automatic penalties for violations - **Availability**: 99.9% uptime with automatic pro-rata refunds for downtime - **Accuracy**: <0.1% error rate or reputation slashing for errors - **Throughput**: 1,000+ requests/second minimum guaranteed capacity **Implementation Details**: - SLA metrics (latency, uptime, accuracy, throughput) measured off-chain by service telemetry - Oracle submits signed attestations or zk/TEE proofs translating off-chain readings to on-chain facts - Contracts evaluate oracle reports to trigger refunds, penalties, or reputation slashing automatically **Result**: Trust through code rather than courts. No legal disputes, just programmatic execution. ### Programmable Trust / Intent-Based Authorization Users express intentions through mathematical constraints that compile to blockchain enforcement: **Spending Rules (On-Chain)**: Asset or stablecoin-related rules leveraging programmable money: - **Spending caps**: Cannot be exceeded even if agent tries - **Rolling windows**: "$1,000 per day" enforced at protocol level - **Whitelisted merchants**: Only authorized recipients can receive funds - **Conditional logic**: "If volatility >20%, reduce limits by half" Evaluated entirely on-chain through smart contracts for transparency and decentralization. Integrates with any on-chain account. Common use cases: spending limits, temporal constraints, merchant restrictions. **Policies (Off-Chain)**: Full control and flexibility for complex logic: - Evaluated securely off-chain in user's local environment or Kite's TEE (Trusted Execution Environment) - Platform-specific but can integrate third-party systems - Common use cases: Session TTL, operation categories, recipient allowlists **Key Distinction**: - **Spending Rules**: Blockchain-enforced, unstoppable, decentralized - **Policies**: Flexible, complex, platform-optimized **Intent Characteristics**: - Automatically expire preventing forgotten authorizations - Cannot be exceeded regardless of agent behavior or model hallucination - User's intent becomes immutable law enforced mathematically ### Session Keys / Ephemeral Keys Temporary cryptographic keys implementing zero-trust session management: **Generation**: - Created for each agent task - **Completely random**, never derived from permanent keys - Ensures **perfect forward secrecy** **Authorization Scope**: Example: "Transfer maximum $10 to providers A, B, or C for data feeds between 2:00 PM and 2:05 PM today" - Specific amount limits - Defined recipient set - Narrow time window - Single operation purpose **Security Properties**: - Session executes its authorized operation then becomes **cryptographically void forever** - Total session compromise affects only one operation for minutes with bounded value - Prevents cascading failures that plague traditional API key systems - One breach ≠ total compromise **Local Generation**: - Happens entirely locally without server communication - No private key transmission - DID session registers in agent network with self-contained proof of authority ### Programmable Escrow Contracts Kite extends beyond direct payments with programmable escrow mechanisms embedding smart contracts between agents and merchants: **Framework**: - Buyers issue cryptographically signed payment intents - Funds authorized into escrow accounts with defined expiry conditions - Escrows can be partially or fully released based on verified outcomes - Supports complete lifecycle: authorization, capture, charge, void, reclaim, refund **Key Properties**: - **Noncustodial**: Users retain full control over assets throughout process - **Permissionless**: No central authority required - **Additional operators**: Third-party entities can relay transactions or cover gas costs - **Cryptographically constrained**: All operators bound by payer's signed hash **Standards Integration**: - Leverages ERC-3009 for signature-based gasless preapprovals - Streamlines execution and user experience **Programmability**: As implemented in code, can be extended with: - Dynamic revenue sharing - Token swaps - Conditional privacy modules - Integration with other smart contracts **Result**: Every transaction becomes auditable, reversible, and composable financial primitive. ### Reputation System Trust scores accumulated based on verifiable behavior, not self-reported ratings: **How Reputation Accumulates**: - **Successful payments**: Increase reputation score - **Fast responses**: Boost ratings - **Failed deliveries**: Decrease trust - **SLA violations**: Trigger penalties - **Policy violations**: Reputation slashing **Key Difference from Traditional Systems**: Unlike traditional ratings that can be gamed, Kite's reputation derives from **cryptographic proofs of actual behavior**. Every interaction is verified and immutable. **Benefits of High Reputation**: - Access to better rates - Higher spending limits - Premium services - Preferential treatment **Portability**: - Reputation is **portable across services** - Solves cold-start problem where new relationships begin from zero trust - Agent with proven history on one platform presents verifiable credentials to new services - Bootstrap trust through cryptographic proof rather than promises **Trust Dynamics**: - **Progressive Authorization**: New agents start with minimal permissions ($10 daily limits) - **Behavioral Adjustment**: Successful operations automatically expand capabilities over time - **Verification Economics**: Expensive verification avoided for high-reputation agents ## Three-Layer Identity Architecture The three-tier identity model provides defense-in-depth security where compromising a session affects only one delegation, compromising an agent remains bounded by user-imposed constraints, and user keys are highly unlikely to be compromised as they're secured in local enclaves. ### User Identity (Root Authority) The cryptographic root of trust with ultimate control: **Key Management**: - Private keys live in **secure enclaves, hardware security modules, or protected device storage** - **Never exposed** to agents, services, or the Kite platform itself - Users maintain exclusive control over digital wealth **Authority**: - Can **instantly revoke** all delegated permissions with single transaction - Sets **global constraints** that cascade through all agents - Represents the only point of potential unbounded loss (highly unlikely to occur) **Monitoring**: - Complete monitoring via **immutable proof chains** - Independent access to funds through standard blockchain interfaces - Cryptographic guarantee of sovereignty regardless of Kite's availability **Legal Responsibility**: - Remains legally responsible entity for all agent actions - Bridge between traditional legal frameworks and autonomous systems ### Agent Identity (Delegated Authority) Each AI agent receives its own cryptographic identity with bounded authority: **Key Derivation**: - **Deterministic address** mathematically derived from user's wallet using **BIP-32** hierarchical key derivation - Example: ChatGPT portfolio manager might have address `0x891h42Kk9634C0532925a3b844Bc9e7595f0eB8C` - Anyone can verify agent belongs to user through cryptographic proof - Agent **cannot reverse derivation** to access user's private key **Capabilities**: - Executes complex tasks across multiple services - Handles real money within cryptographically enforced boundaries - Maintains **own wallet** with own balance - Accumulates **own reputation** score - Coordinates with other agents autonomously **Security Properties**: - **Provable ownership** without key exposure - Independent operation within user-defined boundaries - Even **total agent compromise** remains bounded by smart contract constraints - Cannot exceed spending limits or violate user policies **Identity Resolution**: - Human-readable identifiers: `did:kite:alice.eth/chatgpt/portfolio-manager-v1` - Makes authority chains instantly verifiable - Serves as on-chain identity for authorization ### Session Identity (Ephemeral Authority) For each task execution, completely random session keys provide perfect forward secrecy: **Generation**: - **Completely random** session key (e.g., `0x333n88Pq5544D0643036b4c955Cc8f8706g1dD9E`) - **Never derived** from wallet or agent keys - Ensures **perfect forward secrecy** - Generated entirely locally without server communication **Authorization**: - Single-use authorization tokens executing specific actions - No exposure of permanent credentials - Self-contained proof of authority, chain of trust, and validity period **Expiration**: - Session validates through its time window then becomes **permanently invalid** - Even quantum computers cannot resurrect expired sessions - Automatic cleanup prevents forgotten sessions from becoming vulnerabilities **Security Impact**: - Compromising session key affects **only that session's operations** - Past and future sessions remain secure due to independent key generation - Minimizes blast radius of any security breach ### Unified Reputation Flow While funds remain compartmentalized for security, **reputation flows globally**: - Every transaction and interaction contributes to unified reputation score - Reputation accumulated by user-agent pair benefits both entities - Establishes **cryptographic root of trust** spanning users, agents, and services - Creates portable trust that transfers across platforms ## Cryptographic Security Components ### Standing Intent (SI) The root of cryptographic authority representing the user's signed declaration of what an agent may do: **Structure**: ```javascript SI = sign_user( iss: user_address, // Issuer: the authorizing user sub: agent_did, // Subject: the authorized agent caps: { // Capabilities: hard limits max_tx: 100, // Maximum per transaction max_daily: 1000 // Maximum daily aggregate }, exp: timestamp // Expiration: automatic revocation ) ``` **Properties**: - Signed with user's private key becomes **immutable root of trust** - Every subsequent operation must trace back to valid SI - Capabilities define **mathematical boundaries** that cannot be exceeded - Expiration ensures forgotten authorizations cannot persist indefinitely - Cannot be forged without user's private key (cryptographic hardness of ECDSA/EdDSA) ### Delegation Token (DT) Agent authorization for specific sessions enabling operations without exposing permanent credentials: **Structure**: ```javascript DT = sign_agent( iss: agent_did, // Issuer: the delegating agent sub: session_pubkey, // Subject: the session key intent_hash: H(SI), // Link: hash of Standing Intent operation: op_details, // Scope: specific operation exp: now + 60s // Expiration: short lived (typically 60s) ) ``` **Properties**: - Cryptographically proves agent authorized this session for this operation - Hash linkage ensures agent cannot exceed user-defined Standing Intent limits - Short expiration minimizes exposure from compromised sessions - Operation scope prevents session reuse for unauthorized actions ### Session Signature (SS) Final cryptographic proof for transaction execution: **Structure**: ```javascript SS = sign_session( tx_details, // Complete transaction data nonce, // Replay prevention challenge // Freshness proof ) ``` **Verification Flow**: Services verify **all three signatures** before accepting operations: 1. **Standing Intent** proves user authorization 2. **Delegation Token** proves agent delegation 3. **Session Signature** proves current execution This **triple verification** makes unauthorized actions cryptographically impossible (not merely prohibited). ## Protocol Compatibility ### Identity Resolution Public resolvers enable instant verification without contacting Kite or the user: **Resolution Functions**: - `GetAgent(AgentID)` → AgentID, AgentDomain, AgentAddress - `ResolveAgentByDomain(AgentDomain)` → AgentID, AgentDomain, AgentAddress - `ResolveAgentByAddress(AgentAddress)` → AgentID, AgentDomain, AgentAddress - `GetAgentBySession(SessionID)` → AgentID, AgentDomain, AgentAddress, SessionInfo **Benefits**: - Any service can verify complete authority chain - No API calls to central authority required - Enables permissionless interoperability - Instant trust verification based on cryptographic proof ### Native Protocol Support **A2A Protocol (Agent-to-Agent)**: - Direct agent coordination across platforms - Google's protocol for inter-agent communication - Kite agents speak A2A fluently with agents from any ecosystem **Agent Payment Protocol (AP2)**: - Neutral, open protocol defining how agent payments should be expressed - Similar to ERC-20 for payments - Kite plays the execution layer: enforces AP2 intents on-chain with programmable spend rules **MCP (Model Context Protocol)**: - Model interoperability across entire LLM ecosystem (Anthropic's protocol) - Claude, GPT, and emerging models interact through same protocol layer - Makes model choice business decision rather than technical constraint **OAuth 2.1**: - Enterprise compatibility with existing authentication systems - Backward compatibility means existing services accepting OAuth today can accept Kite agents tomorrow - Minimal changes required for service integration **X402 Standard**: - Agent-native payments for future developments - Forward compatibility with emerging payment standards **Integration Approach**: Rather than creating isolated protocol, Kite embraces existing standards as first principles. Developers don't choose between Kite and existing stack—they add Kite to enhance what already works. ## State Channels and Micropayments ### Payment Channel Architecture Direct money transfers work for occasional payments but fail for agent patterns. State channels enable off-chain transactions with two on-chain anchors: **Mechanics**: - **Open**: Lock funds on-chain - **Transact**: Exchange thousands of signed updates off-chain - **Close**: Settle final state on-chain **Performance**: - High throughput (thousands of transactions per channel) - Low latency (sub-100ms) - Fees amortized across millions of interactions - AI inference at $1 per million requests becomes economically viable ### Channel Variants **Unidirectional Channels**: - Flow value from user to merchant - Perfect for API consumption, data feeds, inference requests - Value flows one direction with simple metering **Bidirectional Channels**: - Enable refunds, credits, two-way value exchange - Services can pay agents for data - Agents can receive rebates - Errors trigger automatic refunds **Programmable Escrow Channels**: - Embed custom logic in state transitions - EVM developers write arbitrary rules - Conditional releases, multi-party splits, time-locked vesting - Channel becomes mini smart contract **Virtual Channels**: - Route value through intermediaries without new on-chain contracts - Agent A pays Agent C through hub B - Network effects without setup overhead **Privacy-Preserving Channels**: - Only channel opens and closes appear on-chain - Thousands of micropayments remain private between participants - Protects competitive intelligence and usage patterns ### How Channel Limitations Become Advantages State channels have known limitations from Ethereum origins, but agent use patterns transform these into features: **Open/Close Overhead**: - Agents send hundreds of inferences to same service over minutes - Setup costs amortize perfectly across concentrated bursts - "Overhead" becomes negligible **Liveness Assumption**: - Professional services with reputation at stake won't risk fraud for micropayments - Services maintain high availability in their best interest **Griefing Attacks**: - Agents and services maintain reputation scores - Griefing destroys reputation for minimal gain (economically irrational) **Fixed Participants**: - Agent interactions naturally have fixed participants (user, agent, service) - Relationships determined at task initiation - Inability to change participants adds security **Sequential Processing**: - Agent interactions inherently turn-based: request → response → request - Limitation perfectly matches use case --- # About Kite URL: https://docs.gokite.ai/about Background on Kite: why it exists, how it is built, and the token behind it. --- # Introduction & Mission URL: https://docs.gokite.ai/about/introduction-and-mission #### Current State of Internet Today's internet was designed only for humans, but AI agents will have even more significant roles in near future. Without a new approach, it will suffer from lack of identity, trust, and scalable payments. ![](/images/get-started/introduction-and-mission/image-4-.png) ## Kite — Foundational Infrastructure for the Agentic Economy * AI agents are becoming main player of economy * However, infrastructure is not ready * It is risky for users to delegate payments to AI agents since AI agent is blackbox * It is risky for merchants to receive payments from AI agents since there is no clear liability on those payments * Kite is **a foundational infrastructure empowering autonomous agents to operate and transact with identity, payment, governance, and verification.** ## Why Kite ? Kite introduces, the first infrastructure system designed from first principles for the agentic economy. We present the **SPACE framework** as the complete solution: * **Stablecoin-native:** Every transaction settles in stablecoins with predictable sub-cent fees * **Programmable constraints:** Spending rules enforced cryptographically, not through trust * **Agent-first authentication:** Hierarchical wallets with cryptographic principal binding * **Compliance-ready:** Immutable audit trails with privacy-preserving selective disclosure * **Economically viable micropayments:** True pay-per-request economics at global scale **Our Core Innovations** **Three-Layer Identity Architecture**\ We introduce the first hierarchical identity model that separates user (root authority), agent (delegated authority), and session (ephemeral authority) identities. Each agent receives its own deterministic address derived from the user's wallet using BIP-32, while session keys are completely random and expire after use. This defense-in-depth architecture ensures graduated security: compromising a session affects only one delegation; compromising an agent remains bounded by user-imposed constraints; and user keys secured in local enclaves inaccessible to any external third parties, which are thus highly unlikely to be compromised, represent the only point of potential unbounded loss. While funds remain compartmentalized for security, reputation flows globally across the system. Every transaction and interaction contributes to a unified reputation score, establishing a cryptographic root of trust that spans users, agents, and services throughout the Kite platform. **Programmable Governance Beyond Smart Contracts**\ While smart contracts enable programmable money, agents require compositional rules that span multiple services. Kite implements a unified smart contract account model where users own a single on-chain account holding shared funds. Multiple verified agents operate through session keys with cryptographically enforced spending rules: "ChatGPT limit $10,000/month, Cursor limit $2,000/month, other agents limit $500/month." Rules can be temporal (e.g., increase limits over time), conditional (e.g., reduce limits if volatility spikes), and hierarchical (cascade through delegation levels). These aren't policies, but programmatically enforced boundaries. **Agent-Native Payment Rails with State Channels**\ Beyond stablecoins and payments-first blockchains, the real revolution goes deeper. Kite creates agent-first transaction types. Beyond simple transfers, Kite implements programmable micropayment channels optimized for agent patterns. Instead of the traditional over-complicated multi-party card rails of authenticate, request, pay, wait, and verify, payments are instantly settled during agent interaction within the same channel. Two on-chain transactions (open and close) enable thousands of off-chain signed updates, achieving sub-hundred-millisecond latency at $1 per million requests. This architectural inversion, treating per-request and streaming micropayments as first-class behaviors with sub-cent precision and instant finality, unlocks agent-native economics which were previously impossible. In the following chapters, we will detail how Kite's architecture, protocols, and implementations solve each infrastructure failure, transforming the promise of the agentic economy into operational reality. The agentic future isn't waiting for better models. It's waiting for infrastructure that treats agents as first-class economic actors. **Footnote:** - Kite is fully **x402-compatible**, enabling standardized agent-to-agent (A2A) intents, verifiable message passing, escrowed execution, and cross-protocol settlement. This ensures seamless interoperability across emerging agentic ecosystems and intent-based coordination protocols. ## Quick Start ### Start with Kite Agent Passport The fastest way to experience Kite is to give an AI agent a Passport — a funded wallet with scoped, you-approved spending. * [**Get a Passport**](/passport) - Set up an agent that can pay for services on your behalf * [**Fund Your Wallet**](/passport/payments/funding) - Add USDC so your agent can transact * [**CLI Reference**](/reference/kpass-cli) - Full `kpass` / `ksearch` command reference ### For Blockchain Developers * [**Kite Chain Getting Started**](../kite-chain/1-getting-started/) - Network information and tools * [**Smart Contract Development**](../kite-chain/3-developing/) - Building smart contracts on Kite * [**Sample dApps**](../kite-chain/4-building-dapps/) - Example dApp implementations [![GitHub](https://img.shields.io/badge/GitHub-Repository-181717?style=for-the-badge\&logo=github)](https://github.com/gokite-ai) [![X](https://img.shields.io/badge/X-Follow-000000?style=for-the-badge\&logo=x)](https://x.com/GoKiteAI) [![Discord](https://img.shields.io/badge/Discord-Join-5865F2?style=for-the-badge\&logo=discord)](https://discord.gg/Gqvh6hv9qt) *** Built with ❤️ by the Kite community --- # Key Use Cases & Players URL: https://docs.gokite.ai/about/key-use-cases-and-players ## Retail: Agentic Commerce **What it is:** Consumers use personal AI agents for end to end online shopping, with and without human interference. **Current Problems:** - Consumer is risky to delegate full payment consent to AI agents - Merchant is risky to receive payments from unknown AI entities, which creates anti-money laundering and other fraud concerns **How Kite Helps:** - Delegation and guardrails with Kite Passport, which consumer can configure granular controls, and identify both consumer and agent. - Payment is always associated with verifiable proof of delegation, which also clarify authenticated user and agent. - Kite Payment API for merchants to verify the proof, initiate stablecoin transfers, verify payments. ## Manufacturing: Automatic Sourcing **What it is:** AI-powered sourcing optimization for manufacturing (cost, lead time, production planning, carbon emissions) including autonomous ordering from manufacturer's agents to suppliers. **Current Problems:** - Both manufacturers and suppliers risky to rely transaction on AI agents as the same as agentic commerce - High foreign exchange costs for international payments **How Kite Helps:** - Secure delegation mechanisms by Kite Passport and delegation proof. - Stablecoin payments instead of traditional FX which helps exchange cost savings. ## Fintech: Investment Portfolio Management **What it is:** AI-driven trading strategy and portfolio optimization. **Current Problems:** - Traders have to take transactions and operation control with limited prompt instructions. **How Kite Helps:** - Programmable and guardrails for investment constraints and risk management ## Digital Services: Agent-powered Monetization **What it is:** Data, model, and tool services specifically designed for AI agents. **Current Problems:** - AI agents lack a trusted way to handle complex micro-transactions autonomously. - Pay-per-use monetization for APIs, data, and tools is difficult to integrate. - Existing payment systems introduce latency and manual intervention, breaking automation. **How Kite Helps:** - Verifiable, autonomous payment infrastructure for AI agents through Kite Passport and delegation proof. - Kite Passport to enable agent actions for easy integration. - Kite Chain for instant, low-latency settlement through stablecoin-based transactions. --- # MiCA Whitepaper URL: https://docs.gokite.ai/about/mica-whitepaper Access Kite's MiCA whitepaper: --- # Tokenomics URL: https://docs.gokite.ai/about/tokenomics ### The Mission of Kite AI Kite AI is building the first blockchain for agentic payments, a foundational platform where autonomous AI agents can operate with verifiable identity, programmable governance, and seamless payments. The company's purpose-built Layer-1 blockchain and Agent Passport system enable AI agents to function as first-class economic actors, creating emergent capabilities through composable interactions. Founded by AI and data infrastructure veterans from Databricks, Uber, and UC Berkeley, Kite AI has raised $35 million from top-tier investors, including PayPal, General Catalyst, Coinbase Ventures and leading blockchain foundations. ### Kite AI Network Overview The Kite AI blockchain is a Proof‑of‑Stake (PoS) EVM‑compatible Layer‑1 chain that serves as a low‑cost, real‑time payment mechanism and coordination layer necessary for autonomous agents to interoperate. Alongside the L1 is a suite of modules, modular ecosystems that expose curated AI services (e.g., data, models, and agents) to users. Modules operate as semi‑independent communities that interact with the L1 for settlement and attribution, while providing specialized environments tailored to particular verticals. Together, the L1 and Modules form a tightly coupled ecosystem where users may assume distinct roles module owners, validators, or delegators and the native token KITE drives incentives, staking, and governance. ### KITE Token Utilities The utility of the KITE token will be rolled out in two phases: Phase 1 utilities are introduced at the time of token generation so that early adopters can immediately participate in the Kite network, while Phase 2 utilities will be added with the launch of the Mainnet. ### Phase 1 Utilities **Module Liquidity Requirements -** Module owners who have their own tokens must lock KITE into permanent liquidity pools paired with their module tokens to activate their modules. This requirement scales with module size and usage, creating deep liquidity while removing tokens from circulation. Liquidity positions are non-withdrawable while modules remain active, ensuring long-term token commitment from the most value-generating participants. **Ecosystem Access & Eligibility -** Builders and AI service providers must hold KITE to be eligible to integrate into the Kite ecosystem. This gives the KITE token immediate utility as an access token to participate in the agentic payment ecosystem and aligns the interests of businesses and builders with that of the Kite network as a whole. **Ecosystem Incentives -** A portion of the KITE supply will be distributed to users and businesses who bring value to the Kite ecosystem. ### Phase 2 Utilities **AI Service Commissions -** The protocol collects a small commission from each AI service transaction and can swap it for KITE on the open market before distributing it to the module and the Kite L1. This ensures that service operators receive payment in their currency of choice while the module and L1 can receive native tokens that increase their stake and influence within the ecosystem. Protocol margins are converted from stablecoin revenues into KITE, creating continuous buy pressure tied directly to real AI service usage and revenues, ensuring token value scales with network adoption. **Staking -** Staking KITE secures the network and grants users eligibility to perform services in exchange for rewards. Module owners develop, operate, and manage a module on the Kite network, validators participate in a Proof-of-Stake consensus, and delegators stake tokens to secure and support modules they find value in. **Governance -** Token holders vote on protocol upgrades, incentive structures, and module performance requirements, aligning the interests of stakeholders with long‑term network health. ### Modules, Validators, and Delegators Kite validators secure the network by staking tokens and participating in consensus. Each validator selects a specific module to stake on, so that incentives are aligned with that module’s performance. Core responsibilities include maintaining network security and consensus stability, participating in governance and voting, and advancing community collaboration and ecosystem growth. Kite delegators stake tokens to secure the network. Each delegator must select a specific module to stake on, aligning their incentives with that module’s performance. Delegators are expected to take part in ecosystem governance and engage with the community. Modules, validators, and delegators receive token emissions through a novel continuous reward system designed to incentivize long-term holding. Participants accumulate KITE rewards over time in a "piggy bank"—they can claim and sell their accumulated tokens at any point, but doing so permanently voids all future emissions to that address. The mechanism transforms token recipients into long-term aligned stakeholders who must weigh immediate liquidity against ongoing value accrual. ### Initial KITE Allocation The total supply of KITE is capped at 10 billion and distributed as follows. ![](/images/get-started-why-kite/tokenomics/image-1-.png) **Ecosystem and Community (48%) -** Ecosystem and community tokens are dedicated to accelerating user adoption, builder and developer engagement, and ecosystem liquidity. They will fund community airdrops, liquidity programs, and growth initiatives that expand participation, reward meaningful contributions, and drive Kite’s transition from launch to broad utility. **Investors (12%) -** Investor tokens are distributed under structured vesting schedules to align investor interests with the network's long-term growth, ensuring that early financial supporters remain committed as the ecosystem expands. **Modules (20%) -** Tokens allocated to modules will be used to incentivize the development of high-quality AI services and to expand the infrastructure that enables users to interact seamlessly with the Kite ecosystem. These funds will support developer grants, performance-based rewards, and the build-out of services that enhance both the intelligence and accessibility of the network. **Team, Advisors, and Early Contributors (20%) -** Tokens allocated to the team, advisors, and early contributors align the long-term incentives of Kite’s builders with the network’s sustained success. These allocations reward early contributors, developers, and strategic advisors who are building and scaling the network, with multi-year vesting schedules that promote stability and accountability as the ecosystem matures. ![](/images/get-started-why-kite/tokenomics/image.png) ### The Kite Network Value Capture **Revenue-Driven Network Growth -** Kite AI implements multiple mechanisms that directly tie token value to network revenues and usage. A percentage of fees from AI service transactions is collected as commission for modules and the network. This ensures the token can benefit directly from every transaction on the network. As modules grow and generate more revenue, additional KITE is locked into their liquidity pools. **Non-Inflationary Economics -** Unlike traditional PoS networks that rely on perpetual token inflation, KITE transitions rapidly from emissions-based rewards to a sustainable model powered entirely by protocol revenues. Initial emissions from a dedicated reward pool bootstrap early network participation, but the system is designed to transition to revenue-driven rewards funded by real AI service usage. This ensures token holders are never diluted by inflation–instead, rewards come directly from value created within the ecosystem. Together, these mechanisms create a tokenomic system where real AI demand directly drives token value through multiple reinforcing loops: service usage generates revenues, successful modules lock more liquidity, and high-value participants are incentivized to continue creating value capture for the Kite network. The result is a token whose value is fundamentally linked to the utility and adoption of the Kite AI network.\\ --- # Whitepaper URL: https://docs.gokite.ai/about/whitepaper-references Explore our technical and research papers that describe the foundations of Kite. *** * From Human-Centric to Agent-Native: Building Trustless Payment Infrastructure for Agentic AI --- # LayerZero Integration on Kite AI URL: https://docs.gokite.ai/kite-chain/10-layerzero-kite-integration LayerZero is natively supported on Kite AI Mainnet, enabling secure omnichain messaging, asset transfers, and cross-chain application composition. This page provides architectural context and operational guidance for developers building cross-chain applications on Kite AI using LayerZero v2. ## Execution Model and Network Guarantees Kite AI nodes form the backbone of the network. They power consensus, secure transactions, propagate state, and ensure deterministic execution for agents, users, and applications deployed on Kite Chain. LayerZero integrations operate directly on top of this core infrastructure: - Inbound and outbound omnichain messages are executed by Kite nodes - Validators secure cross-chain execution and state transitions - Executors rely on Kite's EVM compatibility and gas semantics - Applications depend on deterministic execution for settlement and agent workflows As a result, the reliability and security guarantees of Kite's node and execution model are fundamental to the correct operation of omnichain applications. Understanding Kite's execution environment is therefore an important prerequisite when deploying: - LayerZero-based applications - Omnichain fungible tokens (OFTs) - Cross-chain agent-driven settlement flows ## Supported LayerZero Version Kite AI supports LayerZero v2, which enables smart contracts deployed on Kite AI to communicate with contracts on other supported chains without custodial bridges. LayerZero provides: - Verifiable message delivery - Independent validation via oracle + relayer - Deterministic execution guarantees This makes it suitable for production-grade DeFi, payments, governance, and agent-based systems. ## What Developers Can Build Using LayerZero on Kite AI, developers and partners can build: - Omnichain applications with cross-chain function calls - Omnichain fungible tokens (OFTs) and bridged ERC-20 assets - Cross-chain governance, automation, and settlement flows - Agent-native workflows spanning execution and payment across multiple chains These patterns are commonly used in DeFi, programmable payments, automation pipelines, and agent orchestration systems. ## Architecture Overview LayerZero enables cross-chain communication through a combination of on-chain and off-chain components: - **Endpoint (v2)** - The on-chain contract on Kite AI that serves as the entry and exit point for all LayerZero messages. - **Send and Receive ULNs (Ultra-Light Nodes)** - Verification libraries that validate cross-chain state without requiring full light clients. - **Executor** - A contract responsible for executing verified messages on the destination chain with controlled gas and safety limits. Messages are verified independently by an oracle and a relayer. This separation preserves security while remaining lightweight and efficient. ## Deployed LayerZero Contracts on Kite AI (Mainnet) LayerZero core contracts are already deployed on Kite AI Mainnet. The canonical and always up-to-date source for contract addresses is maintained by LayerZero: https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=kite ### Kite Mainnet Deployment Metadata - **Chain ID:** 2366 - **Endpoint ID (eid):** 30406 - **Network:** Mainnet **Important:** - Endpoint IDs (eid) are not related to EVM Chain IDs. - `30xxx` → Mainnet endpoints - `40xxx` → Testnet endpoints ### Contracts | Contract | Address | Description | |----------|---------|-------------| | EndpointV2 | `0x6F475642a6e85809B1c36Fa62763669b1b48DD5B` | Primary entry point into LayerZero v2. Manages message sending, receiving, and configuration for OApps. | | SendUln302 | `0xC39161c743D0307EB9BCc9FEF03eeb9Dc4802de7` | Message library used for sending cross-chain messages securely. | | ReceiveUln302 | `0xe1844c5D63a9543023008D332Bd3d2e6f1FE1043` | Message library used for receiving and verifying cross-chain messages. | | Blocked Message Library | `0xc1ce56b2099ca68720592583c7984cab4b6d7e7a` | Safety library for blocking misconfigured or invalid message paths. | | LZ Executor | `0x4208D6E27538189bB48E603D6123A94b8Abe0A0b` | Executes verified messages on Kite AI with a defined gas limit and msg.value. | | LZ Dead DVN | `0x6788f52439ACA6BFF597d3eeC2DC9a44B8FEE842` | Placeholder DVN used when default configs are inactive and manual configuration is required. | To check whether a destination chain is supported, use the `isSupportedEid()` method on the Endpoint contract. ## Omnichain Fungible Tokens (OFT) Kite AI supports Omnichain Fungible Tokens (OFTs) via LayerZero. Common OFT use cases include: - Bridged ERC-20 representations of assets from other chains - Native omnichain tokens with a unified total supply - Agent-controlled settlement assets used across multiple networks Depending on the asset design, OFTs typically follow: - Lock-and-mint patterns, or - Burn-and-release patterns ## Testing and Deployment Flow A typical LayerZero deployment workflow on Kite AI: 1. Deploy the application or token contract on Kite AI 2. Deploy corresponding contracts on destination chains 3. Configure trusted peers on all chains 4. Fund sender accounts with native KITE for gas 5. Send test messages and verify execution 6. Monitor delivery and handle failures if needed ## Security and Best Practices When integrating LayerZero on Kite AI: - Always verify and strictly configure trusted peer addresses - Use reentrancy guards when modifying state - Version message payloads to support upgrades - Keep receive handlers minimal and auditable - Monitor failed or reverted message executions These practices are essential for production-grade omnichain deployments. ## References - [LayerZero documentation](https://docs.layerzero.network/v2) - [Kite AI LayerZero Deployment Registry](https://docs.layerzero.network/v2/deployments/deployed-contracts?chains=kite) --- # Indexing Kite AI with Goldsky URL: https://docs.gokite.ai/kite-chain/11-goldsky-kite-integration ## Overview Goldsky provides high-performance blockchain data infrastructure for Kite AI, making it easy to extract, transform, and serve on-chain data for both production apps and analytics workloads. For Kite AI builders, Goldsky is the recommended indexing layer for: * dApps and dashboards * Agent analytics and observability * Protocol monitoring and data pipelines * Real-time and historical on-chain queries Goldsky supports two primary data access models: * **Subgraphs** – High-performance, GraphQL-based indexing * **Mirror** – Real-time replication pipelines into databases and warehouses ## Documentation Index Before diving deeper, you can fetch Goldsky's full documentation index here: https://docs.goldsky.com/chains/kite-ai#indexing-kite-ai-with-goldsky This index lists all available pages, guides, and references, and is useful for discovering advanced features before implementing a specific flow. ## Getting Started To index Kite AI with Goldsky, you'll need to: 1. Create a Goldsky account 2. Install the Goldsky CLI 3. Authenticate using an API key Note - Using Goldsky from the UI is as simple as clicking "+ New subgraph" to get started: ![Kite Subgraph UI](/images/kite-chain/11-goldsky-kite-integration/Kite_Subgraph-UI.png) ### Install the Goldsky CLI & Log In **For macOS/Linux:** ```bash curl https://goldsky.com | sh ``` **For Windows:** ```bash npm install -g @goldskycom/cli ``` ### Create an API Key 1. Go to Project Settings in the Goldsky dashboard 2. Generate a new API key for your project ### Authenticate via CLI ```bash goldsky login ``` ### Verify Installation ```bash goldsky ``` ## Indexing Kite AI with Subgraphs Subgraphs are the most common way to index Kite AI contracts and events. Goldsky supports two deployment paths, depending on how much control you need. ### Option 1: Deploy a Custom Subgraph (Full Control) Use this option if you want: * Custom schemas * Derived entities * Complex mappings or transformations **Requirements:** * `subgraph.yaml` * `schema.graphql` * Mapping files (AssemblyScript) **Deploy command:** ```bash goldsky subgraph deploy / --path . ``` ### Option 2: Instant Subgraphs (Quick Start) Use instant subgraphs if you want: * Fast setup * Minimal configuration * Event-level indexing from an ABI You only need: * Contract address * ABI file **Deploy command:** ```bash goldsky subgraph deploy / \ --from-abi \ --network ``` Goldsky automatically generates: * `subgraph.yaml` * Schema * Event mappings ## Kite AI Network Configuration Use the following chain slugs when deploying subgraphs for Kite AI: | Network | Chain Slug | |---------|------------| | Kite AI Mainnet | `kite-ai` | | Kite AI Testnet | `kite-ai-testnet` | These slugs are required for: * Subgraph deployments * Instant subgraphs * Mirror pipelines ## Common Kite AI Use Cases Builders commonly use Goldsky on Kite AI for: * Agent payment flows & settlement tracking * ERC-20 / native token analytics * Protocol-level metrics (TPS, volume, usage) * Explorer backends & dashboards * Agent reputation, activity, and lifecycle analytics Goldsky pairs especially well with agent-native apps that require: * Low-latency reads * Deterministic historical queries * Scalable analytics without running infra ## Getting Support If you run into issues or need help with advanced setups: **Goldsky Support:** support@goldsky.com --- # Kite Integration with Lucid URL: https://docs.gokite.ai/kite-chain/12-lucid-kite-integration Lucid has integrated with Kite to bring native yield-generating stablecoin liquidity (USDC) to the Kite ecosystem. This integration enables developers, apps, and ecosystem partners to use canonical, cross-chain stablecoins that automatically generate yield while remaining fully redeemable across supported networks. ## Lucid's Native Yield Layer for Stablecoin Liquidity Lucid's Kite is a native yield layer for stablecoin liquidity that transforms idle USDC into yield-bearing assets without changing their usability. Kite introduces L-USDC, a bridge-agnostic, yield-generating version of USDC designed to operate seamlessly across chains. This integration provides ecosystems with a canonical stablecoin layer that works from day one—without fragmentation or custom bridge logic, a unified stablecoin primitive for cross-chain apps, DeFi protocols, and infrastructure partners building on Kite. ## High-Level Architecture Kite consists of four core components: ### 1. Lock Contracts Each Kite asset has a dedicated lock contract that holds native USDC on a selected lock chain. * Default lock chains: * USDC → Arbitrum * Configurable per ecosystem or deployment * Manages collateral custody, withdrawals, and yield deposits * Supports isolated pools for custom deployments ### 2. Yield Layer * 90% of collateral is deposited into Aave v3 to generate yield * 10% remains on-chain as an immediate withdrawal buffer * Automated rebalancing maintains buffer thresholds * Supports future expansion to additional money markets * Optional isolated strategies for ecosystems requiring custom risk profiles ### 3. Mint & Burn System * L-USDC is minted and burned via Lucid's multi-bridge routing architecture * Supports all major bridge ecosystems * Minting occurs once collateral reaches the lock chain * Burning releases collateral back to the user via routed settlement ### 4. Multi-Hop Routing Engine * Enables single-flow transactions across multiple bridges * Users can start on any supported chain and mint L-stables on their target chain * Eliminates the need for direct canonical bridge paths * Improves UX and liquidity accessibility across fragmented ecosystems ## Liquidity & Risk Management ### Liquidity Buffer * Maintains a minimum 10% on-chain buffer for immediate redemptions ### Automated Rebalancing * Continuously rebalances between Aave and lock contracts * Ensures buffer availability while maximizing capital efficiency ### Just-In-Time Liquidity * If withdrawals exceed buffer capacity, liquidity is pulled from Aave automatically * Settles within standard bridge timelines ### Utilization Monitoring * Monitors Aave pool utilization in real time * Dynamically increases buffer size during high-stress periods ## Minting & Redemption Flow ### Minting 1. User sends USDC on any supported chain 2. Multi-hop routing moves funds to the lock chain 3. Lock contract registers collateral 4. L-USDC is minted on the destination chain 5. Yield generation begins automatically ### Redemption 1. User burns L-USDC 2. Collateral is released from the lock contract 3. JIT liquidity is used if buffer is insufficient 4. Native stablecoin is routed back to the user ## Security & Audits * Audited smart contracts * Lock contracts, mint/burn controllers, and yield logic audited by Halborn * Continuous monitoring and operational safeguards * Designed for institutional-grade deployments ## Controller Contracts for Kite ### KiteAI (chain id: 2366) #### USDC * **Controller:** `0x92E2391d0836e10b9e5EAB5d56BfC286Fadec25b` * **Deployed Chains:** Avalanche, KiteAI * **Activated bridge adapters:** LayerZero * **Token on Avalanche:** `0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e` * **Token on KiteAI:** `0x7aB6f3ed87C42eF0aDb67Ed95090f8bF5240149e` #### WETH * **Controller:** `0x638d1c70c7b047b192eB88657B411F84fAc74681` * **Deployed Chains:** Avalanche, KiteAI * **Activated bridge adapters:** LayerZero * **Token on Avalanche:** `0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB` * **Token on KiteAI:** `0x3D66d6c3201190952e8EA973F59c4428b32D5F9b` #### USDT * **Controller:** `0x80bA7204f060Fd321BFE8d4F3aB2E2bF4e6fCe49` * **Deployed Chains:** Celo, KiteAI * **Activated bridge adapters:** LayerZero * **Token on KiteAI:** `0x3Fdd283C4c43A60398bf93CA01a8a8BD773a755b` For technical details, please visit [Lucid Labs documentation](https://docs.lucidlabs.fi/developer-reference/deployed-contracts/controller-contracts#kiteai-chain-id-2366). ## Summary Kite brings yield-generating, bridge-agnostic stablecoins to the Kite ecosystem through Lucid's infrastructure. With automated liquidity management, multi-hop routing, isolated deployment support, and audited smart contracts, Kite provides a production-ready stablecoin layer for developers, protocols, and ecosystem partners building cross-chain applications. --- # Security at Kite URL: https://docs.gokite.ai/kite-chain/6-reference ## Security at Kite At Kite, security is not an afterthought, it’s built into the architecture. We implement a shift-left security mindset, applying best practices from design to production. Through layered defenses, independent audits, and an internal Security Officer overseeing continuous DevSecOps monitoring, we ensure that every component of the Kite AI Layer-1 and its services meets global security standards. Our Security Principles:\ * First-class citizen: Security, reliability, and safety are treated as core UX. Features do not ship unless they meet security acceptance criteria. * Shift-Left: Threat modeling, secure design reviews, and automated checks start at the ideation and PRD (Product requirement Design) stage, not after code freeze. * Defense-in-Depth: Multiple independent layers protect keys, code, infrastructure, and funds; single points of failure are designed out. * Least Privilege & Zero Trust: Minimize blast radius through scoped roles, short-lived credentials, strong auth, and continuous verification. * Transparency & Verifiability: On-chain proofs, public audit artifacts, and immutable changelogs where possible. * Independent Assurance: We engage top security firms ( such as Halborn) for smart-contract and protocol audits, and commission independent penetration tests by reputed security partner. * Verified Authorization: By combining multi-signature (multi-sig) wallet technology with advanced access controls, Kite minimizes single points of failure and ensures that critical operations always require verified authorization. * 24/7 monitoring for both Web2.0 and Web3.0 vulnerabilities and incidents. **Note:** We will publish audit reports and pen-test summaries (with sanitized details) on demand. --- # Stablecoin Gasless Transfer: Integration Guide URL: https://docs.gokite.ai/kite-chain/9-gasless-integration This page provides practical integration instructions for using Kite's Stablecoin Gasless Transfer service. It is intended for developers who want to implement gasless token transfers using signed authorizations (EIP-3009). **Design & Architecture** - For protocol rationale, trust model, and design considerations, refer to [Stablecoin Gasless Transfer – Design Guide](/kite-chain/8-kite-stablecoin/stablecoin-gasless-transfer) Kite Stablecoin ## Overview Kite's Gasless Transfer service allows users to transfer supported stablecoins without holding native gas tokens. Instead, transactions are authorized off-chain using EIP-3009 signed messages, and executed on-chain by Kite's relayer infrastructure. This model enables: - Gasless UX for users - Secure, replay-protected transfers - Wallet and agent-based payment flows - Enterprise-friendly stablecoin payments ## Supported Networks - **Testnet** - **Mainnet** Network selection is done via the request path: **Service endpoint** - `https://gasless.gokite.ai` ## Testnet Token Claim For testnet integration and end-to-end testing, developers can mint testnet `PYUSD` themselves before submitting gasless transfer requests. The `PYUSD` token on Kite Testnet includes built-in `claim` and `claimTo` functions. The contract has been verified on Testnet Kitescan, so builders can: - Use the Kitescan contract page to call the write methods directly - Create and send `claim` or `claimTo` transactions from their own scripts or wallets **Testnet PYUSD contract:** [`0x8E04D099b1a8Dd20E6caD4b2Ab2B405B98242ec9`](https://testnet.kitescan.ai/address/0x8E04D099b1a8Dd20E6caD4b2Ab2B405B98242ec9?tab=read_write_contract) ## API Reference ### List Supported Tokens Retrieve the list of tokens enabled for gasless transfers on each network. **Endpoint** - `GET /supported_tokens` **Example Request:** ```bash curl https://gasless.gokite.ai/supported_tokens | jq . ``` **Example Response:** ```json { "mainnet": [ { "address": "0x7aB6f3ed87C42eF0aDb67Ed95090f8bF5240149e", "balance_threshold": "0", "decimals": 6, "eip712_name": "Bridged USDC (Kite AI)", "eip712_version": "2", "minimum_transfer_amount": "10000", "name": "Bridged USDC (Kite AI)", "symbol": "USDC.e" } ], "testnet": [ { "address": "0x8E04D099b1a8Dd20E6caD4b2Ab2B405B98242ec9", "balance_threshold": "0", "decimals": 18, "eip712_name": "PYUSD", "eip712_version": "1", "minimum_transfer_amount": "10000000000000000", "name": "PYUSD", "symbol": "PYUSD" } ] } ``` **Response Fields:** - `address`: The contract address of the token - `balance_threshold`: The minimum balance required for the sender to use this service (in token's smallest unit) - `decimals`: The number of decimals used by the token - `eip712_name`: The EIP-712 domain name used for signature generation - `eip712_version`: The EIP-712 domain version used for signature generation - `minimum_transfer_amount`: The minimum transfer amount allowed (in token's smallest unit, e.g., wei) - `name`: The display name of the token - `symbol`: The token symbol ### Submit Transfer Request Submit a gasless transfer request using EIP-3009 signed authorization. **Endpoint:** `POST /testnet` or `POST /mainnet` **Request Path:** - Use `/testnet` for testnet network transfers - Use `/mainnet` for mainnet network transfers **Request Method:** `POST` **Request Body Example:** ```json { "from": "0x570DEDa407f5fC26Fc2016E19FD4B65Cb8446914F", "to": "0x2Ba214b0AfCa4Cad5A6A9b8AF05032cE574F16e6", "value": "1000", "validAfter": "1768925639", "validBefore": "1768925888", "tokenAddress": "0x7aB6f3ed87C42eF0aDb67Ed95090f8bF5240149e", "nonce": "0x55ce4241653a0efe60c6272d39dd7b13eba92b482bf46e101b3af92af6443a2c", "v": 27, "r": "0x82cf40577c6520f48a57f089c9ea48bdeb7cb3f687b5fdbaf495a582d137c12e", "s": "0x06be1848101880d34337cebb5fc535ffa2d462b8cca92e9784b62835bbc46d17" } ``` **Request Parameters:** All parameters follow the EIP-3009 specification: - **Network Path**: Use `/testnet` or `/mainnet` according to your target network - `tokenAddress`: Must be a token address listed in the `/supported_tokens` API response - `value`: The transfer amount in the token's smallest unit (e.g., wei for 18-decimal tokens) - `validAfter`: The timestamp after which the transfer is valid. Must be greater than the latest block timestamp of the associated Kite network, otherwise the transaction simulation will fail - `validBefore`: The timestamp before which the transfer must be executed. Currently, transfers are only accepted within 30 seconds from the current time - `nonce`: A unique nonce for this transfer. Each nonce can only be used once - `v`, `r`, `s`: ECDSA signature components. See EIP-3009 for detailed signature generation instructions **Response Fields:** - `txHash`: The transaction hash for the gasless transfer. ## Implementation Reference For a complete TypeScript implementation example demonstrating how to generate the EIP-3009 signature and submit the request, refer to: [GitHub EIP-3009 example](https://gist.github.com/thor-wong/2438c0e3970e22c75f4302ac2d75ac1b) --- # Kite Passport URL: https://docs.gokite.ai/passport Kite Passport lets your agent pay for paid services on your behalf under spending limits you control. You approve a spending session with your passkey — after that, your agent handles discovery, payment, and fulfillment on its own until the session expires or runs out of budget. ## Pay for a service in three steps 1. **[Install the CLI and sign in](/passport/install)** — Install `kpass`, create your Passport account, and set up your passkey. 2. **[Approve a spending session](/passport/payments)** — Fund your Passport wallet with USDC and approve a spending session that sets your agent's budget, per-transaction limit, and time window. 3. **Let your agent pay** — Your agent discovers services, requests payments, and completes transactions on your behalf within the limits you approved. ## What your agent can pay for - **Paid APIs from the Kite catalog** — Services that use x402 payment requests for API access. - **Wallet sends** — Direct USDC transfers your agent initiates within session limits. --- # Install the CLI and agent skills URL: https://docs.gokite.ai/passport/install Passport works with two kinds of agents: coding agents that run on your computer and cloud agents that run on a hosted computer. Setup differs only in how you install, and sign-in is the same. ## Coding agents ### Claude Desktop The Claude.ai website will not work for this flow. Use the Claude Desktop app. 1. Install Claude Desktop and sign in: [Claude Desktop quickstart](https://code.claude.com/docs/en/desktop-quickstart). 2. Open the Code section in Claude Desktop. 3. Paste this prompt into Claude: ```text Run this command to install Kite Agent Passport: curl -fsSL https://cli.gokite.ai/install.sh | bash ``` ![Install Kite Agent Passport](/images/kite-agent-passport/beginner-setup/introduction-1-install.png) 4. When install finishes, tell Claude: ```text Sign me up to Kite Passport. ``` ![Sign up with your agent](/images/kite-agent-passport/beginner-setup/02-signup-agent.png) 5. Set up agent skills: ```bash kpass skills setup --global --agent claude --yes ``` For other Claude setup paths, see: - [Claude Code terminal quickstart](https://code.claude.com/docs/en/quickstart) - [Claude Code with VS Code](https://code.claude.com/docs/en/vs-code) ### Codex App 1. Open Codex and sign in with your ChatGPT account: [Codex](https://chatgpt.com/codex/). 2. Select a folder or Git repository where Codex can work. 3. Paste this prompt into Codex: ```text Run this command to install Kite Agent Passport: curl -fsSL https://cli.gokite.ai/install.sh | bash ``` ![Install Kite Agent Passport](/images/kite-agent-passport/beginner-setup/introduction-1-install.png) 4. When install finishes, tell Codex: ```text Sign me up to Kite Passport. ``` ![Sign up with your agent](/images/kite-agent-passport/beginner-setup/02-signup-agent.png) 5. Set up agent skills: ```bash kpass skills setup --global --agent codex --yes ``` For other Codex setup paths, see: - [Codex CLI](https://developers.openai.com/codex/cli) - [Codex IDE extension](https://developers.openai.com/codex/ide) ## Cloud agents A cloud agent runs on a computer its provider hosts, so you don't open a terminal. ### Grok Bot Send this line on its own: > Set up Kite Passport from github.com/gokite-ai/passport-skills. ### Muse Send this line on its own: > Set up Kite Passport from github.com/gokite-ai/passport-skills. Then: This setup grants the hosted agent access to your Kite Passport account. Review the session limits before approving. 1. Open approval links on your phone and approve with your passkey 2. Paste into the chat the 8-character login code that arrives by email (Muse's email connector hides the code, so copy it from your inbox yourself) ## Sign in After installation, you will receive two emails: - A verification link that opens the Passport dashboard - An 8-character code to paste back into your agent Click the verification link first. The dashboard will ask you to create a passkey using Touch ID, Face ID, Windows Hello, or a hardware key. After that, paste the 8-character code into your agent chat. ## Next step [Pay for a service](/passport/payments) to fund the wallet, approve a spending session and pay. --- # Service Provider Guide URL: https://docs.gokite.ai/passport/seller Kite Agent Passport can pay any service that implements one of two open payment protocols: - **x402** — HTTP 402-based payment protocol with on-chain settlement - **MPP (Machine Payments Protocol)** — an open standard by Stripe and Tempo for machine-to-machine payments ([mpp.dev](https://mpp.dev/)) If your service already speaks either protocol, Passport agents can pay you today. If you are starting fresh, this guide walks through both options. We encourage deploying on **Kite chain** for the fastest settlement and tightest integration with Passport. --- ## How Passport Pays Your Service 1. An agent calls your service endpoint. 2. Your service returns **402 Payment Required** with payment terms. 3. The Passport agent resolves payment using the user's approved spending session. 4. Your service receives proof of payment, verifies it, and delivers the response. The specifics of step 2–4 depend on which protocol you implement. --- ## Option 1: Accept Payments via x402 x402 uses HTTP 402 responses to negotiate on-chain payments between agents and services. ### Payment Flow ![Payment Flow](/images/kite-agent-passport/service-provider-guide/payment_flow.png) 1. Your service returns a **402 Payment Required** response with payment details. 2. The Passport agent obtains a signed payment authorization from the user's session. 3. The agent resends the request with the `X-Payment` header. 4. You verify the payment token and call a facilitator to settle on-chain. 5. The facilitator executes the transfer to your wallet. 6. You deliver the service response. ### Kite Facilitator Kite works with any x402-compatible facilitator. The recommended facilitator for Kite chain: | Property | Value | |----------|-------| | **Service** | Pieverse Facilitator | | **Version** | 2.0.0 | | **Base URL** | https://facilitator.pieverse.io | | **Documentation** | https://facilitator.pieverse.io/ | **API Endpoints:** | Endpoint | Method | Description | |----------|--------|-------------| | `/v2/verify` | POST | Verify payment signature | | `/v2/settle` | POST | Settle payment (execute on-chain) | The facilitator handles on-chain execution. Once payment is authorized, it calls `transferWithAuthorization` and transfers funds directly to your payee address. ### Implementing x402 in Your Service **Step 1: Return 402 Payment Required** When a request arrives without valid payment, return a 402 with your payment terms: ```json { "error": "X-PAYMENT header is required", "accepts": [{ "scheme": "gokite-aa", "network": "", "maxAmountRequired": "1000000000000000000", "resource": "https://your-service.com/api/endpoint", "description": "Your API - Description of your service", "mimeType": "application/json", "outputSchema": { "input": { "discoverable": true, "method": "GET", "queryParams": { "param1": {"description": "Parameter description", "required": true, "type": "string"} }, "type": "http" }, "output": { "properties": { "result": {"description": "Result description", "type": "string"} }, "required": ["result"], "type": "object" } }, "payTo": "0xYourServiceWalletAddress", "maxTimeoutSeconds": 300, "asset": "", "extra": null, "merchantName": "Your Service Name" }], "x402Version": 1 } ``` **Key Response Fields:** | Field | Description | Example | |-------|-------------|---------| | `scheme` | Payment scheme | `gokite-aa` | | `network` | Target network | `` | | `maxAmountRequired` | Maximum payment amount (in wei) | `1000000000000000000` (1 token) | | `asset` | Token contract address | `` | | `payTo` | Your service wallet address | `0xYourServiceWalletAddress` | | `maxTimeoutSeconds` | Payment timeout | `300` | | `merchantName` | Your service name | `Your Service Name` | | `outputSchema` | API input/output specification | (see above) | **Step 2: Receive and Verify the Payment Token** The agent resends the request with an `X-Payment` header containing a base64-encoded authorization: ```bash curl -H "X-PAYMENT: eyJhdXRob3JpemF0aW9uIjp7..." \ https://your-service.com/api/endpoint ``` **Step 3: Settle via Facilitator** ```bash curl -X POST https://facilitator.pieverse.io/v2/settle \ -H "Content-Type: application/json" \ -d '{ "authorization": {...}, "signature": "0x...", "network": "" }' ``` **Step 4:** After confirming settlement, deliver your service response. ### x402 Resources - **x402 Protocol Specification:** https://docs.x402.org/introduction - **Pieverse Facilitator Docs:** https://facilitator.pieverse.io/ --- ## Option 2: Accept Payments via MPP MPP (Machine Payments Protocol) is an open standard co-authored by Stripe and Tempo. It extends the HTTP 402 pattern with support for multiple payment methods, session-based billing, and IETF standardization. ### Payment Flow 1. Agent requests a resource from your service. 2. Your service responds with a **402 challenge** containing payment terms. 3. The agent submits a **credential** (proof of payment). 4. Your service verifies the credential, returns a **receipt**, and delivers the resource. ### Key Differences from x402 | | x402 | MPP | |---|---|---| | **Payment methods** | On-chain stablecoins | Stablecoins, fiat (Stripe), and more | | **Settlement** | Via facilitator on-chain | Via Stripe or supported payment networks | | **Transport** | HTTP headers (`X-Payment`) | HTTP, JSON-RPC, WebSocket | | **Session support** | Via Passport spending sessions | Built-in payment channels | ### Getting Started with MPP - **MPP Specification:** [mpp.dev](https://mpp.dev/) - **Stripe MPP Blog:** [stripe.com/blog/machine-payments-protocol](https://stripe.com/blog/machine-payments-protocol) --- ## Next Steps 1. **Pick your protocol** — x402 for on-chain payments on Kite, or MPP for multi-method support. 2. **Set up a service wallet** on Kite chain (for x402) or connect Stripe (for MPP). 3. **Implement 402 responses** in your service. 4. **Test with Passport** — follow the [Introduction](/passport) to create an agent and pay your service. --- # Build with an LLM URL: https://docs.gokite.ai/reference/build-with-an-llm Kite provides machine-readable documentation surfaces designed for AI agents and LLMs to access and understand our documentation. ## Documentation Surfaces for Agents ### llms.txt Access the core documentation in a format optimized for LLMs at `/llms.txt`. This provides essential Kite documentation in a compact, agent-friendly format. ### llms-full.txt For comprehensive documentation access, use `/llms-full.txt`. This includes the full documentation set with extended detail. ## MCP Documentation Search The `/mcp` endpoint provides a **docs search server only**. It enables agents to search and retrieve Kite documentation. Kite does not have a payment MCP. Agents pay through the Passport skills and `kpass`. ## Using Kite Passport for Payments For agent payments, use the Kite Passport skills and the `kpass` CLI: - [Install the CLI and agent skills](/passport/install) - [Buyer quickstart](/passport/payments) - [Passport skills repository](https://github.com/gokite-ai/passport-skills) The Passport skills integrate directly with AI agents to enable agentic payments without requiring a separate MCP payment interface. --- # Error Codes URL: https://docs.gokite.ai/reference/error-codes When an agent executes a paid request through a spending session, the backend enforces the session's budget and scope constraints. If a request violates these constraints, the payment is refused with one of the error codes below. The agent reads the error code from the response and takes the appropriate recovery action. ## Session Spending Errors ### session_rule_exceeded **What it means:** A single transaction exceeds the session's `max_amount_per_tx` limit. **What the agent does:** The agent cannot proceed with this transaction. Before creating a new session, the agent presents the proposed session parameters to the user and waits for explicit confirmation. The agent must then request a new session with a higher per-transaction limit. The agent does not re-authenticate and does not retry the same request against the same session. ### session_total_exceeded **What it means:** The cumulative spending across all transactions in this session exceeds the session's `max_total_amount` budget. **What the agent does:** The session's budget is exhausted. Before creating a new session, the agent presents the proposed session parameters to the user and waits for explicit confirmation. The agent must then request a new session with sufficient budget to complete the remaining work. The agent does not re-authenticate and does not retry the same request against the same session. ### session_endpoint_forbidden **What it means:** The agent attempted to access an endpoint outside the session's scope constraints. The session was created with `execution_constraints` that restrict which endpoints the agent can call (e.g., only `/api/weather` or only `example.com`), and this request fell outside that scope. **What the agent does:** The agent cannot proceed with this endpoint. Before creating a new session, the agent presents the proposed session parameters to the user and waits for explicit confirmation. The agent must then request a new session with broader scope constraints that include the target endpoint. The agent does not re-authenticate and does not retry the same request against the same session. ## Other Session Errors Additional error codes returned during session creation or execution include: - **session_asset_forbidden** - **session_forbidden** - **session_owner_forbidden** - **payment_target_forbidden** - **payment_redirect_not_allowed** - **session_request_forbidden** For all of these, the agent inspects the `hint` field in the error response for recovery guidance. Before creating a new session, the agent presents the proposed session parameters to the user and waits for explicit confirmation, then creates a new session with corrected parameters. --- # Reference URL: https://docs.gokite.ai/reference This section holds command-line references, agent skills, error codes, and API specifications for developers building with Kite Passport. - [kpass CLI](/reference/kpass-cli) — All commands for authentication, wallet management, agent registration, spending sessions, and paid request execution. - [Passport Skills](/reference/passport-skills) — The 16 user-group skills that teach AI agents how to authenticate, manage sessions, execute payments, and transfer tokens. - [Error Codes](/reference/error-codes) — Session spending errors and what the agent does next. - [Build with an LLM](/reference/build-with-an-llm) — Machine-readable docs (llms.txt, llms-full.txt) and the docs search MCP for AI agents. - [API Reference](/api-reference) — HTTP API specifications for the Kite backend. --- # kpass CLI URL: https://docs.gokite.ai/reference/kpass-cli This page documents the `kpass` and `ksearch` commands. For getting started, see the current [Kite Passport docs](/passport). ## kpass `kpass` is the Passport CLI for authentication, wallet management, agent registration, spending sessions, and paid request execution. ### General Flags | Flag | Description | | --- | --- | | `--output json` | Machine-readable JSON output (recommended when agents drive the CLI) | | `--no-interactive` | Never prompt for stdin input (required for automation) | | `--base-url ` | Override the default backend URL | ### Status and Health ```bash kpass status # Overall status: backend, auth, agent, session kpass health --output json # Backend connectivity check kpass --version # Installed version ``` ### Authentication #### Sign Up (New User) ```bash kpass signup init --email you@example.com --output json ``` After clicking the verification email link: ```bash kpass signup poll --signup-id --wait --output json kpass signup exchange --signup-id --exchange-token --output json ``` #### Log In (Returning User) ```bash kpass login init --email you@example.com --output json ``` Enter the 8-character code from the email: ```bash kpass login verify --login-id --code --output json ``` #### Confirm Identity ```bash kpass me --output json ``` ### Wallet ```bash kpass wallet balance --output json # Show wallet address and balances kpass wallet send --to
--amount --asset USDC --output json # Send funds to another wallet ``` ### Agent Registration ```bash kpass agent:register --type coding-assistant --output json # Register a new agent kpass user agents --output json # List agents owned by the logged-in user ``` Common `--type` values: `coding-assistant`, `research-agent`, or a label matching your use case. ### Spending Sessions #### Create a Session ```bash kpass agent:session create \ --task-summary "Discover paid services and execute one approved API call" \ --max-amount-per-tx 2 \ --max-total-amount 10 \ --ttl 24h \ --assets USDC \ --payment-approach x402_http \ --output json ``` | Flag | Description | | --- | --- | | `--task-summary` | Human-readable description of what the agent will do | | `--max-amount-per-tx` | Maximum spend per single transaction | | `--max-total-amount` | Maximum total spend for the session | | `--ttl` | Session lifetime (e.g. `1h`, `24h`) | | `--assets` | Token(s) the session can spend | | `--payment-approach` | Payment protocol (`x402_http`) | #### Approve and Monitor ```bash kpass agent:session status --request-id --wait --output json # Wait for user approval kpass agent:session list --status active --output json # List active sessions kpass agent:session use --session-id --output json # Switch active session kpass user sessions --status active --output json # List sessions across agents ``` #### Execute a Paid Request ```bash kpass agent:session execute \ --url "https://x402.dev.gokite.ai/api/weather?location=San%20Francisco" \ --method GET \ --output json ``` With headers and body (POST): ```bash kpass agent:session execute \ --url https://api.example.com/paid-endpoint \ --method POST \ --headers '{"Content-Type":"application/json"}' \ --body '{"query":"hello"}' \ --output json ``` ### Skills The install flow adds Kite Passport skills to your coding agent: | Skill | Purpose | | --- | --- | | `authenticate-user` | Sign up or log in | | `kite-discovery` | Search the service catalog | | `request-session` | Create and approve spending sessions | | `x402-execute` | Execute paid requests | | `wallet-send` | Direct wallet transfers | | `manage-agents` | Register and list agents | Inspect installed skills: ```bash npx --yes skills add gokite-ai/passport-skills --list ``` --- ## ksearch `ksearch` is the service discovery CLI for searching and inspecting paid services in the Kite catalog. ### Search Services ```bash ksearch services list \ --query weather \ --payment-approach x402_http \ --asset USDC \ --limit 10 \ --output json ``` | Flag | Description | | --- | --- | | `--query` | Search by topic or keyword | | `--payment-approach` | Filter by payment protocol (`x402_http`) | | `--asset` | Filter by payment asset (`USDC`) | | `--limit` | Maximum number of results | ### Inspect a Service ```bash ksearch services get --service-id --output json ``` ### Export Catalog ```bash ksearch export markdown --output-dir ./.kite/catalog ``` ### Health Check ```bash ksearch health --output json ksearch --version ``` --- ## Tips - Use `--output json` and `--no-interactive` together when an agent drives the workflow. - With a global install, `kpass` keeps one login in the home folder (`.kite-passport/` there) and uses it from every folder. With a local (project) install, each project keeps its own login in its `.kite-passport/` folder. - `signup` sends an email verification link. `login` sends an 8-character code. If you already have an account, use login. - Direct wallet transfers use `kpass wallet send`. Agentic service payments use `agent:session create` + `agent:session execute`. --- # Passport Skills URL: https://docs.gokite.ai/reference/passport-skills The Passport Skills collection teaches AI agents how to authenticate users, manage spending sessions, execute payments, and transfer tokens using the `kpass` CLI. These 16 user-group skills are invoked by human operators via Claude Code, Cursor, Cline, and other agent hosts. ## Skills 1. **Kite Passport** — Orchestrator skill for paid-services catalog: creative/media generation, external AI compute, live data, commerce, wallet operations, and communication. Invoke first when the user wants any of these capabilities. 2. **Upgrade Passport** — Detect and apply `kpass` CLI updates automatically. Invoke when an `update_available` field appears in command output or the user asks to update. 3. **Kite Discovery** — Find and explore paid APIs, AI models, and data services in the Kite catalog via `ksearch`. Use before generic web search when no specific tool has been named. 4. **Authenticate User** — Sign up or log in to Kite Passport. Required before payments, wallet operations, or session creation. Invoke when auth errors occur. 5. **Request Session** — Create spending sessions that authorize the agent to spend on behalf of the user. Handles agent registration, merchant preflight, delegation construction, and user approval via passkey. Required before any payment or paid API call. 6. **Attach Session** — Attach an existing attachable session (pre-created in the Passport web dashboard) to this agent by session ID. Binds with owner passkey approval; does not create new sessions. 7. **Form Session Delegation** — Construct delegation objects for agent session creation. Covers preflight discovery, 402 response parsing, and delegation schema. Called by request-session, not directly by users. 8. **x402 Execute** — Make paid API requests through an approved spending session. The backend handles x402 payment negotiation automatically. Requires an active session. 9. **Wallet Send** — Check multichain wallet balance, send crypto, and look up per-chain wallet addresses. Works directly with the user's wallet; no spending session required. Sends require passkey approval in the browser. 10. **DeFi Auto-Repay** — Arm a one-shot Aave v3 auto-repay on Base: when the health factor of an Aave position drops below a threshold, Kite repays its USDC debt once from the user's Passport wallet. 11. **Manage Agents** — Inspect registered agents and spending sessions on the user's account. Read-only diagnostics for debugging agent registration or session errors. 12. **Activity Feed** — View transaction history and recent account activity. Covers wallet transfers, API payments, agent registrations, and session approvals. 13. **Report Feedback** — Submit free-form feedback or issue reports from the current agent session to Passport. Invoke when the user reports a bug or describes a failure worth surfacing. 14. **Passport Setup** — Install and verify the `kpass` CLI on this computer before running any other Passport skill. Invoke automatically when `kpass` is missing or command-not-found errors occur. 15. **Kite Router** — Run synchronous text-model inference through Kite Router with this Passport-bound agent. Uses `kpass agent router`; does not handle delayed jobs. ## Installation Install these skills with: ```bash kpass skills setup ``` See [Installing Passport](/passport/install) for complete setup instructions. --- # Add Kite Tokens to an External Wallet URL: https://docs.gokite.ai/kite-chain/1-getting-started/add-kite-tokens-external-wallet If you need to access KITE tokens or USDC.e in your external wallet (e.g., MetaMask), you will need to add Kite Network information to your wallet. > Note: You will need KITE tokens for gas fees to send tokens on the Kite Network. ## Follow These Steps 1. Open your wallet (MetaMask, Rabby, or any EVM-compatible wallet) and switch networks ![MetaMask switch network](/images/kite-agent-passport/add-kite-tokens-external-wallet/mm-switch-network.png) 2. Navigate to the "Custom" Network section ![MetaMask add custom network](/images/kite-agent-passport/add-kite-tokens-external-wallet/mm-switch-to-custom-network.png) 3. Click **Add custom network** and enter the following details. Once completed, you will see the Kite network and your KITE token balance in your wallet. | Field | Value | |---|---| | **Network Name** | KiteAI | | **Default RPC URL** | https://rpc.gokite.ai/ | | **Chain ID** | 2366 | | **Token** | KITE | | **Block Explorer URL** | https://kitescan.ai/ | > For more network information, refer to the [Network Information](/kite-chain/1-getting-started/network-information) page. 4. To add USDC.e to your wallet, ensure you're on the Kite Network and click **Import tokens**. ![MetaMask import tokens](/images/kite-agent-passport/add-kite-tokens-external-wallet/mm-import-tokens.png) 5. Paste the USDC.e token contract address: ``` 0x7aB6f3ed87C42eF0aDb67Ed95090f8bF5240149e ``` > Note: The above steps were shown through MetaMask. While the exact steps might be slightly different, this process will work with any EVM-compatible wallet. ### Acquire KITE Tokens You can get KITE tokens through supported exchanges or bridges. Once acquired, send them to your external wallet address on Kite chain. --- # FAQs URL: https://docs.gokite.ai/kite-chain/1-getting-started/faqs ## What is the Kite platform and why build on it? Kite is a sovereign Layer-1 blockchain designed specifically for AI-centric applications, offering high throughput and low latency for complex AI workloads. * **Open AI Marketplace:** It provides an open marketplace for datasets and AI agents, enabling easy discovery and monetization. * **Customizable Modules:** Developers can create or join specialized modules to optimize data pipelines, privacy, and computational performance for targeted AI use cases. * **Ownership and Rewards:** By leveraging this specialized infrastructure, you can **own** your data and models, control pricing for usage, and receive **transparent rewards** for contributions. ## How can I deploy my AI agents on this platform? There are two ways to deploy your agents and models: through the GUI and through the CLI (coming soon). Steps explained below: * **Develop Your Agent:** Package your AI logic as a Docker image. * **Publish and Deploy:** Use the provided CLI tools to publish and deploy your AI agent onto your chosen module or the default community module. * **Manage Agents:** Through the dashboard, you can manage your agents, monitor usage, set your pricing, and track income distribution. ## How does the monetization or incentive structure work? The monetization and incentive structure is based on the role of the participant and the contribution or demand of their attribution to the platform. * **Token-Based Rewards:** Contributors (e.g., AI Builders, Data Providers, AI infra partners) earn platform tokens based on usage of their assets (datasets or agents or Infra). * **Marketplace Listing:** When you publish data or an AI agent, you set the price. Consumers pay in tokens upon usage; the platform tracks usage automatically. * **Income Distribution:** Module owners and creators can withdraw accrued income and distribute it among contributors in their module. ## How do I select modules, and how many can I use? Each module can be optimized for specific use cases, high-throughput data ingestion, specialized AI modeling, etc. * **Flexibility:** You can join multiple modules if your projects span different domains. * **Access Controls:** Some modules are invite-only (private), while others are open to all developers. ## Can I become a module owner and also a validator? * Yes. Module owners manage membership, invite new participants, and oversee reward distribution. * You can also run a validator node to secure the module, confirm transactions, and earn token rewards for those services. ## What do validators do on KITE blockchain and how are rewards earned? * **Transaction Confirmation:** Validators confirm transactions and maintain network security. * **Earning Rewards:** They earn tokens for providing these services, with rewards often tied to factors like stake, workload, or accuracy. * **Staking:** By staking tokens, validators ensure security and can receive proportional rewards. ## What privacy measures does the platform offer for data? On the Kite platform, users can choose to process data locally or in a controlled-access environment. * **Sovereign Control:** Owners have full control over how data is shared and monetized. * **Secure, Decentralized Infrastructure:** The Layer-1 design ensures data attribution is secure and usage is transparent. ## Is there a step-by-step guide on how to upload data, especially if I process large volumes daily? Large datasets can be uploaded through the CLI for agents (in progress) and through the Python SDK. The steps are detailed below: * **Create a Dataset:** In the dashboard, select "Create Dataset." * **Use the Python SDK:** Initialize and authenticate your session, then upload data in batches—especially useful for large-scale processes. * **Publish Your Data:** Set pricing and visibility, then publish. * **Manage Tables:** Organize tables in the data management section to monitor usage, performance, and income. ## How does on-chain registration of platform activities work in practice? Can you provide examples? While there are quite a few activities and events that are tracked on-chain for various use cases, below is a high-level overview of the categories and some examples of on-chain registration (these are also applicable for AI agents and AI models): * **Immutable Record:** Key actions, dataset uploads, agent deployments, income distributions are recorded on-chain. * **Example:** When creating a new dataset, the platform logs a transaction with the dataset's metadata and ownership details. Subsequent usage (queries, agent calls) also gets recorded, ensuring transparent reward calculations. ## How does the platform plan to integrate with specific decentralized storage solutions? KITE AI emphasizes its built-in decentralized storage and local data processing capabilities. While discussing with third-party integrations (e.g., Filecoin & Walrus) are in flight, exact technical details or timelines are not yet finalised. ## Are there caveats to working with this platform alongside other solutions or independently? Kite AI platform is a decentralised platform for end users, ai builders and data providers. It provides benefits in various ways: * **Open Marketplace:** You have full control over listing your data or agents. * **Collaboration Benefits:** Joining a module can offer shared incentives and community-driven development. * **Independent Deployment:** There are no restrictions on deploying and monetizing your own assets independently, as long as you follow platform guidelines. --- **For more details about Kite, visit:** [**https://gokite.ai**](https://gokite.ai) **or follow us on X at** [**https://x.com/gokiteai**](https://x.com/gokiteai) --- # Getting Started with Kite Chain URL: https://docs.gokite.ai/kite-chain/1-getting-started Welcome to Kite Chain! This section provides everything you need to start building on Kite's blockchain network. ## What You'll Find Here - **[Network Information](/kite-chain/1-getting-started/network-information)** - Chain IDs, RPC endpoints, faucets, and network details - **[Tools](/kite-chain/1-getting-started/tools)** - Block explorers, wallets, SDKs, and DeFi tools for Kite Chain - **[FAQs](/kite-chain/1-getting-started/faqs)** - Common questions and answers about Kite Chain ## Quick Start 1. **Connect to the Network** - Get testnet tokens from the faucet and configure your wallet 2. **Explore the Chain** - Use the block explorer to see transactions and contracts 3. **Set Up Your Environment** - Install the tools you'll need for development ## Next Steps Once you're familiar with the basics: - Learn [Blockchain Fundamentals](/kite-chain/2-fundamentals) if you're new to blockchain - Start [Developing Smart Contracts](/kite-chain/3-developing) on Kite Chain - Build complete [dApps](/kite-chain/4-building-dapps) with frontend interfaces --- *New to blockchain? Check out our [Fundamentals](/kite-chain/2-fundamentals) section first!* --- # Network Information URL: https://docs.gokite.ai/kite-chain/1-getting-started/network-information ## Kite network settings (testnet) * Testnet - * Chain name: KiteAI Testnet * Default RPC URL - [https://rpc-testnet.gokite.ai/](https://rpc-testnet.gokite.ai/) * Chain ID: 2368 * Token: KITE * Block Explorer URL - [https://testnet.kitescan.ai/](https://testnet.kitescan.ai/) ### RPC endpoint * Testnet - [https://rpc-testnet.gokite.ai/](https://rpc-testnet.gokite.ai/) ### Faucet * Testnet - [https://faucet.gokite.ai](https://faucet.gokite.ai) ### ChainList link * Testnet - [https://chainlist.org/chain/2368](https://chainlist.org/chain/2368) ## Kite network settings (mainnet) * Mainnet - * Chain name: KiteAI Mainnet * Default RPC URL - [https://rpc.gokite.ai/](https://rpc.gokite.ai/) * Chain ID: 2366 * Token: KITE * Block Explorer URL - [https://kitescan.ai/](https://kitescan.ai/) ### RPC endpoints * Mainnet HTTPS RPCs * Global - [https://rpc.gokite.ai/](https://rpc.gokite.ai/) * Virginia - [https://rpc-virginia.gokite.ai](https://rpc-virginia.gokite.ai) * Tokyo - [https://rpc-tokyo.gokite.ai](https://rpc-tokyo.gokite.ai) * Ireland - [https://rpc-ireland.gokite.ai](https://rpc-ireland.gokite.ai) * Mainnet WSS RPCs * Global - [wss://rpc.gokite.ai/ws](wss://rpc.gokite.ai/ws) * Virginia - [wss://rpc-virginia.gokite.ai/ws](wss://rpc-virginia.gokite.ai/ws) * Tokyo - [wss://rpc-tokyo.gokite.ai/ws](wss://rpc-tokyo.gokite.ai/ws) * Ireland - [wss://rpc-ireland.gokite.ai/ws](wss://rpc-ireland.gokite.ai/ws) ### ChainList link * Mainnet - [https://chainlist.org/chain/2366](https://chainlist.org/chain/2366) --- # Tools URL: https://docs.gokite.ai/kite-chain/1-getting-started/tools ## Kite tools ### Monitoring and Debugging * Kite Explorer * Testnet - [https://testnet.kitescan.ai/](https://testnet.kitescan.ai/) * Mainnet - [https://kitescan.ai/](https://kitescan.ai/) ### Multi-sig wallet * Wallet –[ https://wallet.ash.center/?network=kite](https://wallet.ash.center/?network=kite) ## Kite Github * Github – [https://github.com/gokite-ai/](https://github.com/gokite-ai/) --- # counter smart contract hardhat URL: https://docs.gokite.ai/kite-chain/3-developing/counter-smart-contract-hardhat Build & Deploy a Counter Contract on Kite AI using Hardhat What is Hardhat? Hardhat is a local development environment for Ethereum-style (EVM) blockchains. It lets you: • Compile, test, and deploy contracts from your machine. • Script deployments and verifications (great for CI/CD). • Fork networks locally, run a local node, and debug with stack traces and console logging. • Use a rich plugin ecosystem (ethers.js, Etherscan-style verification, gas reporters, coverage, etc.). In this section, we will go over Hardhat workflow: - Set up & Scaffold project - Write contract - Compile - Configure network - Deploy via script - Interact via console/scripts Prerequisites: • Node.js 18+ and npm (or pnpm/yarn) • A funded wallet (for Kite testnet/mainnet) • MetaMask (optional - recommended for managing keys) • Git (recommended) ### 1. Create a Hardhat Project: - Create and enter a new folder: `mkdir kite-counter-hardhat && cd kite-counter-hardhat` - Initialize a Node project: `npm init -y` - Install Hardhat and tooling: `npm install --save-dev hardhat @nomicfoundation/hardhat-toolbox dotenv` - Scaffold a Hardhat project (choose “Create a TypeScript project” when prompted): `npx hardhat` This creates a hardhat.config.ts, sample tests, and a basic project structure. ### 2. Add Envrironment variable: Create a .env file in the project root `touch.env` Put your secrets and Kite endpoints in it (replace placeholders): Wallet private key (no 0x prefix or with 0x — Hardhat supports either): PRIVATE_KEY=0xYOUR_PRIVATE_KEY_HERE Kite AI network (testnet or mainnet) RPC: KITE_RPC_URL=https://rpc-testnet.gokite.ai/ Chain ID (number): KITE_CHAIN_ID=2368 KITE EXPLORER URL: KITE_EXPLORER_BROWSER_URL=https://testnet.kitescan.ai/ .gitignore (ensure secrets aren’t committed): node_modules .env cache artifacts typechain-types ### 3. Configure hardhat Open hardhat.config.ts and replace with: ``` import { HardhatUserConfig } from "hardhat/config"; import "@nomicfoundation/hardhat-toolbox"; import * as dotenv from "dotenv"; dotenv.config(); const PRIVATE_KEY = process.env.PRIVATE_KEY || ""; const KITE_RPC_URL = process.env.KITE_RPC_URL || ""; const KITE_CHAIN_ID = process.env.KITE_CHAIN_ID ? Number(process.env.KITE_CHAIN_ID) : undefined; const config: HardhatUserConfig = { solidity: { version: "0.8.20", settings: { optimizer: { enabled: true, runs: 200 } }, }, networks: { // Rename to "kite" or "kiteMainnet" as you prefer kiteTestnet: { url: KITE_RPC_URL, chainId: KITE_CHAIN_ID, accounts: PRIVATE_KEY ? [PRIVATE_KEY] : [], }, }, // Optional: If Kite explorer is Etherscan-compatible, enable this etherscan: { apiKey: { kiteTestnet: process.env.EXPLORER_API_KEY || "", }, customChains: [ { network: "kiteTestnet", chainId: KITE_CHAIN_ID || 0, urls: { apiURL: process.env.KITE_EXPLORER_API_URL || "", browserURL: process.env.KITE_EXPLORER_BROWSER_URL || "", }, }, ], }, }; export default config; ``` ### 4. Write the Counter Contract ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; contract Counter { uint256 public count; function increment() public { count += 1; } function decrement() public { require(count > 0, "Counter cannot be negative"); count -= 1; } function getCount() public view returns (uint256) { return count; } } ``` ### 5. Compile ```npx hardhat compile``` ### 6. Write a Deployment Script Create scripts/deploy.ts: ``` import { ethers } from "hardhat"; async function main() { const Counter = await ethers.getContractFactory("Counter"); const counter = await Counter.deploy(); await counter.waitForDeployment(); const address = await counter.getAddress(); console.log("Counter deployed to:", address); } main().catch((error) => { console.error(error); process.exitCode = 1; }); ``` ### 7. Fund Your Deployer & Add the Network (MetaMask) - Add the Kite AI network to MetaMask using the same RPC URL and Chain ID you placed in .env. - Fund the deployer address with KITE (or test KITE on testnet) to cover gas. - Ensure the private key in .env matches the funded account. ### 8. Deploy to Kite AI ```npx hardhat run scripts/deploy.ts --network kiteTestnet``` Output example: ` Counter deployed to: 0xABCDEF1234567890abcdef1234567890ABCDEF12` Important - Copy and save this address on your notepad. ### 9. Verify if deployment went through successfully - VIsit the explorer site - https://testnet.kitescan.ai/ - Copy and paste the deplotment contract from previous step on the search bar - Look up the deployer details ( your public key) and contract details on the results page. ### 10. Troubleshooting • Insufficient funds for gas * price + value - Fund your deployer wallet with KITE (or test KITE). • Invalid sender / nonce too low - Reset your account nonce in MetaMask or wait for pending txs to clear; you can also specify a higher nonce manually. • Unsupported chainId - Ensure KITE_CHAIN_ID in .env matches the network’s actual chain ID. • No PRIVATE_KEY set - Add PRIVATE_KEY to .env and restart your command. ### 11. Security & Best Practices • Never commit secrets (.env in .gitignore). • Use a deployment-only wallet with limited funds. • For teams, consider multi-sig for production keys and use a deployer bot with restricted permissions. • Pin exact versions in package.json to ensure reproducibility. • Keep compiler optimizations consistent across environments. If you wish to integrate this deployed contract to a front-end with a user interface, visit the below link and follow the steps: - [Counter dApp Tutorial](../4-building-dapps/counter-dapp.md) --- # Counter Smart contract URL: https://docs.gokite.ai/kite-chain/3-developing/counter-smart-contract-remix Please follow the below steps to build your smart contract on Kite AI: ## Step 1: Open [Remix IDE](https://remix.ethereum.org/) * Navigate to Remix IDE in your browser. * Once loaded, you’ll see the file explorer on the left-hand side where you can manage your Solidity files. ## Step 2: Create a New File * In the Remix file explorer, click the ”+” icon to create a new file. * Name your file counter.sol ## Step 3: Write the Solidity Code Copy and paste the following Solidity code into your Counter.sol file: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; contract Counter { uint256 public count; function increment() public { count += 1; } function decrement() public { require(count > 0, "Counter cannot be negative"); count -= 1; } function getCount() public view returns (uint256) { return count; } } ``` This smart contract does the following: * **Stores a counter:** The count variable holds the current value. * **Provides a getter:** Although count is a public variable, the getCount() function is an example of how you can explicitly return data. * **Allows incrementing:** The increment() function increases the counter. * **Allows decrementing:** The decrement() function decreases the counter. ## Step 4: Compile the Contract * On the left sidebar, click the “Solidity Compiler” tab (the one with the “S” icon). * Ensure the compiler version is set to ^0.8.20 version. * Click “Compile Counter.sol”. * Check the code for typos or version mismatches, if you encounter any errors. ## Step 5: Deploy the Contract * Switch to the “Deploy & Run Transactions” tab (the Ethereum icon on the left sidebar). * Under “Environment”, select “Injected Metamask or WalletConnect”. This will connect Remix to your MetaMask (make sure MetaMask is set to the Kite AI Testnet). * Verify that your account is correctly connected. * In the “Contract” dropdown, select Counter. * Click the “Deploy” button. * Confirm the deployment transaction in MetaMask. * Once deployed, your contract will appear under “Deployed Contracts”. ## Step 6: Interact with Your Contract * Expand your deployed Counter contract in Remix. * You can call the getCount() function to check the current counter value. * Click the “increment” button to call the increment() function and “decrement” button to call the decrement() function. Confirm the transaction in MetaMask. * After the transaction is confirmed, call getCount() again to see the updated counter value. Github Link - [https://github.com/gokite-ai/kite\_counter\_dapp](https://github.com/gokite-ai/kite_counter_dapp) --- # Developing Smart Contracts URL: https://docs.gokite.ai/kite-chain/3-developing Learn how to write, deploy, and interact with smart contracts on Kite Chain using industry-standard tools. ## What You'll Build This section walks you through creating smart contracts with practical examples: * [**Setup Environment**](/kite-chain/3-developing/setup-environment) - Configure your development environment with necessary tools * [**Counter Contract - Remix**](/kite-chain/3-developing/counter-smart-contract-remix) - Build a simple counter using Remix IDE * [**Counter Contract - Hardhat**](/kite-chain/3-developing/counter-smart-contract-hardhat) - Build the same contract using Hardhat framework * [**Voting Contract**](/kite-chain/3-developing/voting-smart-contract) - Create a decentralized voting system * [**Smart Contracts List**](/kite-chain/3-developing/smart-contracts-list) - Pre-deployed contracts and libraries available on Kite ## Development Tools Kite Chain supports standard Ethereum development tools: * **Remix IDE** - Browser-based development environment (no installation required) * **Hardhat** - Professional development framework with testing and deployment * **Solidity** - The primary smart contract programming language ## Kite's Smart Contract Framework Kite provides a modular, on-chain framework for building AI-driven applications: * **Creating and managing assets** - Deploy and govern ML models, datasets, agents, and services * **Monetizing resources** - Implement flexible fee distribution for data providers and creators * **Ensuring secure governance** - Leverage role-based access control for transparent collaboration * **Streamlining operations** - Use factories, registries, and job managers for orchestration ## Learning Path 1. **Start with Setup** - Get your development environment ready 2. **Try Remix** - Quick start with browser-based development 3. **Move to Hardhat** - Professional workflows with testing and scripts 4. **Build Real Projects** - Create voting systems and explore pre-deployed contracts ## Next Steps After developing contracts: * Build complete [dApps](/kite-chain/4-building-dapps) with React frontends * Explore [Advanced Features](/kite-chain/5-advanced) like Account Abstraction * Review [Reference Documentation](/kite-chain/6-reference) for production deployments *** _New to smart contracts? Review_ [_Fundamentals_](/kite-chain/2-fundamentals) _first!_ --- # Building on Kite Chain - Network setting & tools URL: https://docs.gokite.ai/kite-chain/3-developing/setup-environment Before we start building smart contracts on Kite, its important to go over this section which is designed to help developers quickly set up all the critical tools required for building on the Kite blockchain. Whether you’re a beginner taking your first steps into Web3 development or an experienced EVM builder looking to dive into advanced integrations, this guide provides the tools, resources, and best practices you need to succeed. Kite AI is EVM-compatible, meaning you can leverage familiar tools like MetaMask, Hardhat, and Remix while exploring novel AI use cases on Kite protocol. ## Kite metamask settings * Testnet - * Chain name: KiteAI Testnet * Default RPC URL - [https://rpc-testnet.gokite.ai/](https://rpc-testnet.gokite.ai/) * Chain ID: 2368 * Token: KITE * Block Explorer URL - [https://testnet.kitescan.ai/](https://testnet.kitescan.ai/) * Mainnet - * Chain name: KiteAI Mainnet * Default RPC URL - [https://rpc.gokite.ai/](https://rpc.gokite.ai/) * Chain ID: 2366 * Token: KITE * Block Explorer URL - [https://kitescan.ai/](https://kitescan.ai/) ### RPC endpoint * Testnet - [https://rpc-testnet.gokite.ai/](https://rpc-testnet.gokite.ai/) * Mainnet - [https://rpc.gokite.ai/](https://rpc.gokite.ai/) ### Monitoring and Debugging * Kite Explorer * Testnet - [https://testnet.kitescan.ai/](https://testnet.kitescan.ai/) * Mainnet - [https://kitescan.ai/](https://kitescan.ai/) ### Faucet * Testnet - [ https://faucet.gokite.ai ](https://faucet.gokite.ai) ### Kite smart contracts After the setting up these tools, switch your metamask to Kite-Testnet chain and then move to the next section and build your first smart contract on Kite blockchain. Follow the tutorial on the next page or click on this link to get started : [Kite AI smart-contracts](https://github.com/gokite-ai/zetta-contracts/tree/develop/examples) --- # Kite Mainnet Contracts List URL: https://docs.gokite.ai/kite-chain/3-developing/smart-contracts-list This page provides a comprehensive list of all smart contracts deployed on Kite Mainnet and related cross-chain deployments. --- ## 1. Validator Staking Contracts Contracts that manage validator/delegator staking, reward calculation, and reward distribution on the Kite L1. | Contract | Address | Description | | -------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | KiteStakingManager (Proxy) | `0x7d627b0F5Ec62155db013B8E7d1Ca9bA53218E82` | Upgradeable proxy for the staking manager. Entry point for validator registration, delegator staking, reward claims, and all staking operations. | | KiteStakingManager (Impl) | `0x065cA4309a5abc9F1cC2d8fA00634BC948C25C6b` | Implementation contract behind the KiteStakingManager proxy. Contains the core staking logic for native KITE token staking. | | RewardVault | `0xd26850d11e8412fC6035750BE6A871dff9091FAe` | Holds native KITE tokens reserved for staking reward distribution. The staking manager calls `distributeReward()` to pay out validator/delegator rewards from this vault. | | FixedAPRRewardCalculator | `0x171eefa30E88f9bca456CEf49c5Df093A516C7c2` | Calculates staking rewards using a fixed APR (simple interest). Reward formula: `stakeAmount * APR * uptimeSeconds / secondsInYear`. Current rate: 2.5% (250 bps). | | ValidatorMessages | `0x9C00629cE712B0255b17A4a657171Acd15720B8C` | Library contract for packing/unpacking ICM (Inter-Chain Messaging) messages used by the validator manager, as specified in ACP-77. | | ProxyAdmin | `0x3FA7667FD726F73ef42c66f8715E0C6d37D44905` | OpenZeppelin ProxyAdmin that manages the KiteStakingManager proxy upgrades. Only the ProxyAdmin owner can trigger implementation upgrades. | --- ## 2. Staking Vault (LST) Contracts Contracts for the liquid staking vault, enabling users to stake KITE and receive liquid staking tokens (LST). | Contract | Address | Description | | ----------------------------- | -------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- | | StakingVault (Proxy) | `0x23f7b52E2830C66f88EFc1f35b8a6a4AAe218dCA` | Upgradeable proxy for the staking vault. User-facing entry point for depositing KITE and receiving LST tokens. | | StakingVault (Impl) | `0x69379f875551A505d77876a9363BcDe3dfd00bbe` | Implementation contract for the StakingVault proxy. Contains the core vault logic (deposit, withdraw, share accounting). | | StakingVaultOperations (Impl) | `0xE31b845a6898D165e3dFc2AD4C3D61fE74394817` | Implementation contract handling operational logic for the staking vault (e.g., delegating staked assets to validators, rebalancing). | --- ## 3. Tokens on Kite Mainnet | Token | Address | Decimals | Description | | ------ | -------------------------------------------- | -------- | -------------------------------------------------------------------------------------------------------------- | | WKITE | `0xcc788DC0486CD2BaacFf287eea1902cc09FbA570` | 18 | Wrapped KITE (ERC-20 wrapper for the native KITE token). Used for DEX trading and DeFi interactions. | | USDC.e | `0x7aB6f3ed87C42eF0aDb67Ed95090f8bF5240149e` | 6 | Bridged USDC stablecoin (deployed and maintained by Lucid Labs). Used for payments, x402 settlement, and DeFi. | | USDT | `0x3Fdd283C4c43A60398bf93CA01a8a8BD773a755b` | 6 | Bridged USDT stablecoin (deployed and maintained by Lucid Labs). | | WETH | `0x3D66d6c3201190952e8EA973F59c4428b32D5F9b` | 18 | Bridged Wrapped Ether (deployed by Lucid Labs). | --- ## 4. Algebra DEX Contracts Algebra Integral concentrated liquidity DEX deployed on Kite Mainnet. | Contract | Address | Description | | -------------------------- | -------------------------------------------- | -------------------------------------------------------------------------------- | | AlgebraFactory | `0x10253594A832f967994b44f33411940533302ACb` | Factory contract that creates and manages Algebra liquidity pools. | | AlgebraPoolDeployer | `0xd7cB0E0692f2D55A17bA81c1fE5501D66774fC4A` | Used by the factory to deploy individual pool contracts via CREATE2. | | SwapRouter | `0x03f8B4b140249Dc7B2503C928E7258CCe1d91F1A` | Router for executing token swaps against Algebra pools. | | NonfungiblePositionManager | `0xD637cbc214Bc3dD354aBb309f4fE717ffdD0B28C` | Manages concentrated liquidity positions as NFTs (ERC-721). | | Multicall3 | `0xE3104A157cc4C0d3c7C3a8c655092668D068c149` | Utility contract for batching multiple read/write calls in a single transaction. | --- ## 5. KITE Token (Cross-Chain) The KITE token deployed on external chains. All deployments are non-upgradeable. BSC and Avalanche share the same address; Ethereum uses a different address. | Network | Address | | ----------------- | -------------------------------------------- | | Ethereum Mainnet | `0x118B70dF4F06Fa5678E7d543e6066e028C8ea0c0` | | BSC Mainnet | `0x904567252D8F48555b7447c67dCA23F0372E16be` | | Avalanche C-Chain | `0x904567252D8F48555b7447c67dCA23F0372E16be` | --- ## 6. LayerZero Bridge Contracts LayerZero contracts for cross-chain messaging on Kite Mainnet. - **LayerZero Chain ID:** 2366 - **LayerZero Endpoint ID:** 30406 | Contract | Address | | ----------------------- | -------------------------------------------- | | EndpointV2 | `0x6F475642a6e85809B1c36Fa62763669b1b48DD5B` | | SendUln302 | `0xC39161c743D0307EB9BCc9FEF03eeb9Dc4802de7` | | ReceiveUln302 | `0xe1844c5D63a9543023008D332Bd3d2e6f1FE1043` | | LZ Executor | `0x4208D6E27538189bB48E603D6123A94b8Abe0A0b` | | LZ Dead DVN | `0x6788f52439ACA6BFF597d3eeC2DC9a44B8FEE842` | | Blocked Message Library | `0xc1ce56b2099ca68720592583c7984cab4b6d7e7a` | --- ## 7. Lucid Bridge Contracts Lucid contracts for cross-chain messaging on Kite Mainnet. | Contract | Address | | --------------------------- | -------------------------------------------- | | USDC Controller (Avalanche) | `0x92E2391d0836e10b9e5EAB5d56BfC286Fadec25b` | | WETH Controller (Avalanche) | `0x638d1c70c7b047b192eB88657B411F84fAc74681` | | USDT Controller (Celo) | `0x80bA7204f060Fd321BFE8d4F3aB2E2bF4e6fCe49` | | USDC Controller (Kite) | `0x92E2391d0836e10b9e5EAB5d56BfC286Fadec25b` | | WETH Controller (Kite) | `0x638d1c70c7b047b192eB88657B411F84fAc74681` | | USDT Controller (Kite) | `0x80bA7204f060Fd321BFE8d4F3aB2E2bF4e6fCe49` | --- # Voting Smart contract URL: https://docs.gokite.ai/kite-chain/3-developing/voting-smart-contract Please follow the below steps to build your smart contract on Kite AI: ## Step 1: Open [Remix IDE](https://remix.ethereum.org/) * Navigate to Remix IDE in your browser. * Once loaded, you’ll see the file explorer on the left-hand side where you can manage your Solidity files. ## Step 2: Create a New File * In the Remix file explorer, click the ”+” icon to create a new file. * Name your file voting.sol ## Step 3: Write the Solidity Code Copy and paste the following Solidity code into your voting.sol file: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; contract Voting { uint public option1Votes; uint public option2Votes; mapping(address => bool) public hasVoted; function voteOption1() public { require(!hasVoted[msg.sender], "Already voted"); option1Votes++; hasVoted[msg.sender] = true; } function voteOption2() public { require(!hasVoted[msg.sender], "Already voted"); option2Votes++; hasVoted[msg.sender] = true; } function getVotes() public view returns (uint, uint) { return (option1Votes, option2Votes); } } ``` This smart contract does the following: * **option1Votes** and **option2Votes** store the vote counts. * **hasVoted** tracks whether an address has already voted. * **voteOption1**() and **voteOption2**() allow one-time voting. * **getVotes**() returns the current counts for both options. ## Step 4: Compile the Contract * On the left sidebar, click the “Solidity Compiler” tab (the one with the “S” icon). * Ensure the compiler version is set to ^0.8.20 version. * Click “Compile voting.sol”. * Check the filename and code for typos or version mismatches, if you encounter any errors. ## Step 5: Deploy the Contract * Switch to the “Deploy & Run Transactions” tab (the Ethereum icon on the left sidebar). * Under “Environment”, select “Injected Metamask or WalletConnect”. This will connect Remix to your MetaMask (make sure MetaMask is set to the Kite AI Testnet). * Verify that your account is correctly connected. * In the “Contract” dropdown, select **voting**. * Click the “Deploy” button and confirm the deployment transaction in MetaMask. * Once deployed, your contract will appear under “Deployed Contracts”. ## Step 6: Interact with Your Contract * Expand your deployed Voting contract in Remix. * Call the getVotes() function to check the current vote counts for both options. * Click the “voteOption1” button to call voteOption1() or the “voteOption2” button to call voteOption2(). Confirm the transaction in MetaMask. * After the transaction is confirmed, call getVotes() again to see the updated vote counts. Github Link - [https://github.com/gokite-ai/kite\_voting\_dapp](https://github.com/gokite-ai/kite_voting_dapp) --- # Counter dApp URL: https://docs.gokite.ai/kite-chain/4-building-dapps/counter-dapp ## Building the dApp with React We will create a simple React app to interact with our counter contract using[ Ethers.js](https://docs.ethers.org/). **Step 1: Set Up React Application** In your project directory, create a new React app using Create React App: ``` npx create-react-app counter-dapp-frontend cd counter-dapp-frontend npm install ethers ``` **Step 2: Create a Counter Component** Replace the content of **src/App.js** with the following code: ``` import React, { useEffect, useState } from 'react'; import { ethers } from 'ethers'; import './App.css'; // Replace with your deployed contract address const CONTRACT_ADDRESS = "YOUR_DEPLOYED_CONTRACT_ADDRESS"; // ABI from your Counter contract const CONTRACT_ABI = [ { "inputs": [], "name": "count", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" }, { "inputs": [], "name": "increment", "outputs": [], "stateMutability": "nonpayable", "type": "function" }, { "inputs": [], "name": "getCount", "outputs": [ { "internalType": "uint256", "name": "", "type": "uint256" } ], "stateMutability": "view", "type": "function" } ]; function App() { const [count, setCount] = useState(0); const [provider, setProvider] = useState(null); const [contract, setContract] = useState(null); // Initialize provider and contract useEffect(() => { if (window.ethereum) { const tempProvider = new ethers.providers.Web3Provider(window.ethereum); setProvider(tempProvider); const tempContract = new ethers.Contract(CONTRACT_ADDRESS, CONTRACT_ABI, tempProvider.getSigner()); setContract(tempContract); // Request account access if needed window.ethereum.request({ method: 'eth_requestAccounts' }); } else { alert("Please install MetaMask!"); } }, []); // Fetch count from contract const fetchCount = async () => { if (contract) { const currentCount = await contract.getCount(); setCount(currentCount.toNumber()); } }; // Call increment function const incrementCount = async () => { if (contract) { const tx = await contract.increment(); await tx.wait(); fetchCount(); } }; useEffect(() => { fetchCount(); }, [contract]); return (

Kite AI Counter DApp

Current Count: {count}

); } export default App; ``` **Important:** Replace "YOUR\_DEPLOYED\_CONTRACT\_ADDRESS" with the actual contract address you received when deploying your contract from the previous step [Developing Smart Contracts](../3-developing) **Step 3: Run the Frontend** Start your React development server: ``` npm start ``` Open your browser and navigate to[ http://localhost:3000](http://localhost:3000). With MetaMask connected to the KiteAI Testnet, you should see your counter value and a button to increment it. See Metamask settings for [KITE AI here. ](../3-developing/setup-environment#kite-metamask-settings) Congratulations on building your basic counter dApp on the Kite AI blockchain testnet! You’ve successfully. Github Link - [https://github.com/gokite-ai/kite\_counter\_dapp](https://github.com/gokite-ai/kite_counter_dapp) --- # Building dApps URL: https://docs.gokite.ai/kite-chain/4-building-dapps Learn how to build complete decentralized applications (dApps) with React frontends that interact with your smart contracts. ## Sample dApps This section provides full-stack examples using React and Ethers.js: * [**Counter dApp**](4-building-dapps/counter-dapp) - Simple counter interface with wallet connection * [**Voting dApp**](4-building-dapps/voting-dapp) - Decentralized voting system with real-time results * [**Token Minter**](4-building-dapps/token-minter) - Create and manage custom tokens ## What You'll Learn * Setting up React applications for Web3 * Connecting to MetaMask and other wallets * Interacting with smart contracts using Ethers.js * Handling transactions and user feedback * Building responsive Web3 UIs ## Tech Stack All examples use modern Web3 development tools: * **React** - Frontend framework * **Ethers.js** - Ethereum library for contract interaction * **MetaMask** - Wallet integration * **Kite Testnet** - Deploy and test your dApps ## Development Workflow 1. **Deploy Smart Contracts** - Use contracts from the [Developing](/kite-chain/3-developing) section 2. **Build Frontend** - Create React components that connect to your contracts 3. **Test Locally** - Run your dApp with a local development server 4. **Deploy** - Host your frontend on Vercel, Netlify, or similar platforms ## Prerequisites Before building dApps: * Complete the [Smart Contract Development](/kite-chain/3-developing) tutorials * Have basic React knowledge * Understand async/await JavaScript patterns ## Next Steps After building dApps: * Explore [Advanced Features](/kite-chain/5-advanced) like Account Abstraction and Multisig * Deploy to production and check [Node Operations](/kite-chain/7-kite-node) *** _Need to deploy contracts first? Check out_ [_Developing Smart Contracts_](/kite-chain/3-developing)_!_ --- # Token Minter URL: https://docs.gokite.ai/kite-chain/4-building-dapps/token-minter ## Deploying an ERC-20 Token on the KiteAI Testnet ### Overview This guide provides a comprehensive walkthrough for deploying an ERC-20 token on the KiteAI Testnet. It covers two primary methods: 1. Remix IDE: A beginner-friendly, browser-based approach. 2. Foundry: A command-line toolchain suitable for advanced users. Before diving into the deployment steps, it's essential to understand the KiteAI network and the significance of deploying on this platform. *** ### Understanding the KiteAI Network #### What is KiteAI? KiteAI is an EVM-compatible L1 blockchain designed to empower decentralized AI economies using, powered by Proof of AI (PoAI). This innovative consensus mechanism that ensures fair attribution and transparent rewards for contributors across agents, models, and data. #### Key Features: * Chain ID: 2368 (0x940) * Native Currency: KITE * Block Gas Limit: 400,000,000 * Testnet Faucet: [https://faucet.gokite.ai/](https://faucet.gokite.ai/) * Network Addition: [Chainlist - KiteAI Testnet](https://chainlist.org/chain/2368) #### Why Deploy on KiteAI? Deploying on the KiteAI network allows developers to: * Test and validate smart contracts in an AI-enhanced environment. * Participate in a forward-thinking ecosystem that combines blockchain and AI technologies. *** ### What You Will Do * Create an ERC-20 token smart contract using OpenZeppelin's standard implementation. * Deploy the contract to the KiteAI Testnet using: * * Remix IDE (beginner-friendly) * Foundry (advanced CLI tool) *** ### What You Will Need * A Web3 wallet (e.g., MetaMask) * Test Kite tokens (claim from [faucet.gokite.ai](https://faucet.gokite.ai/)) * Access to the KiteAI Testnet via MetaMask. (via [Chainlist](https://chainlist.org/chain/2368)) * Basic knowledge of Solidity and smart contract development. *** ### Understanding ERC-20 Token? An ERC-20 token is a standardized smart contract on Ethereum and EVM-compatible blockchains that defines a set of rules for fungible tokens. These rules include how tokens are transferred, how users can access data about a token, and the total supply of tokens. #### Key Functions: * totalSupply(): Returns the total token supply. * balanceOf(address): Returns the account balance of another account with address address. * transfer(address, uint256): Transfers amount of tokens to address recipient. * approve(address, uint256): Allows spender to withdraw from your account multiple times, up to the amount. * transferFrom(address, address, uint256): Transfers amount tokens from address sender to address recipient. * allowance(address, address): Returns the amount which spender is still allowed to withdraw from the owner. *** ### Method 1: Deploying via Remix IDE #### Step 1: Add KiteAI Testnet to MetaMask 1. Visit [Chainlist - KiteAI Testnet](https://chainlist.org/chain/2368). 2. Connect your MetaMask wallet. 3. Add the KiteAI Testnet to your networks. #### Step 2: Obtain Test Kite Tokens 1. Visit the [KiteAI Faucet](https://faucet.gokite.ai/). 2. Connect your MetaMask wallet. 3. Request 0.5 Kite tokens. #### Step 3: Write the Smart Contract 1. Open [Remix IDE](https://remix.ethereum.org). 2. Create a new file named ”MyToken.sol”. Paste the following code: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract MyToken is ERC20 { constructor(uint256 initialSupply) ERC20("MyToken", "MTK") { _mint(msg.sender, initialSupply); } } ``` 3. This contract uses OpenZeppelin's ERC-20 implementation to create a token named "MyToken" with the symbol "MTK". #### Step 4: Compile the Contract 1. Navigate to the "Solidity Compiler" tab in Remix. 2. Ensure the compiler version is set to 0.8.20 or higher. 3. Click "Compile MyToken.sol". #### Step 5: Deploy the Contract 1. Go to the "Deploy & Run Transactions" tab. 2. Set the environment to "Injected Provider - MetaMask". 3. Ensure MetaMask is connected to the KiteAI Testnet. 4. Enter the initial supply (e.g., 1000000 for 1 million tokens). 5. Click "Deploy". 6. Confirm the transaction in MetaMask. Once deployed, your ERC-20 token will be live on the KiteAI Testnet. *** ### Method 2: Deploying via Foundry #### Step 1: Install Foundry If you haven't installed Foundry: ``` curl -L https://foundry.paradigm.xyz | bash foundryup ``` \ #### Step 2: Initialize the Project ``` forge init MyTokenProject cd MyTokenProject ``` \ #### Step 3: Install OpenZeppelin Contracts | forge install OpenZeppelin/openzeppelin-contracts | | ------------------------------------------------- | \ #### Step 4: Configure Remappings In foundry.toml, add: ``` [profile.default] remappings = ["@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/"] ``` \ #### Step 5: Write the Smart Contract Create a new file at src/MyToken.sol: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; contract MyToken is ERC20 { constructor(uint256 initialSupply) ERC20("MyToken", "MTK") { _mint(msg.sender, initialSupply); } } ``` #### Step 6: Create Deployment Script Create a new file at script/Deploy.s.sol: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "forge-std/Script.sol"; import "../src/MyToken.sol"; contract DeployScript is Script { function run() external { vm.startBroadcast(); new MyToken(1000000 * 10 ** 18); vm.stopBroadcast(); } } ``` #### Step 7: Set Environment Variables Create a .env file in the root directory: ``` PRIVATE_KEY=your_private_key RPC_URL=https://rpc-testnet.gokite.ai ``` Replace your\_private\_key with your wallet's private key that holds Kite tokens. #### Step 8: Build and Deploy ``` source .env forge build forge script script/Deploy.s.sol:DeployScript --rpc-url $RPC_URL --private-key $PRIVATE_KEY --broadcast ``` \ After deployment, Foundry will provide the contract address and transaction details. *** ### Conclusion Deploying an ERC-20 token on the KiteAI Testnet is straightforward using either Remix IDE or Foundry. By following this guide, developers can: * Understand the KiteAI network and its unique features. * Write and deploy ERC-20 tokens efficiently. * Choose the deployment method that best suits their experience level. For further exploration, consider integrating additional functionalities into your token, such as minting, burning, or pausing transfers, using OpenZeppelin's extensive library of smart contract modules. \ --- # Voting dApp URL: https://docs.gokite.ai/kite-chain/4-building-dapps/voting-dapp ## Building the dApp with React We will create a simple React app to interact with our voting contract using[ Ethers.js](https://docs.ethers.org/). A sample voting dApp built with KITE AI testnet & React - [kite-voting-dapp.vercel.app/](https://kite-voting-dapp.vercel.app/) **Step 1: Set Up React Application** In your project directory, create a new React app using Create React App: In your project directory, create a new React app using Create React App: ``` npx create-react-app voting-dapp cd voting-dapp npm install ethers ``` **Step 2: Create a Voting Component** Replace the content of **src/App.js** with the following code: ``` import { useState } from "react"; import { ethers } from "ethers"; import CONTRACT_ABI from "../abis/Voting.json"; import "./index.css"; const CONTRACT_ADDRESS = "0x10AD19ad5589Ba45fa8225B41C79021519f64501"; const KITE_TESTNET_CHAIN_ID = 2368; function App() { const [provider, setProvider] = useState(null); const [contract, setContract] = useState(null); const [wallet, setWallet] = useState(null); const [error, setError] = useState(""); const [votes, setVotes] = useState({ option1: 0, option2: 0 }); const [hasVoted, setHasVoted] = useState(false); const connectWallet = async () => { if (!window.ethereum) { setError("Please install MetaMask!"); return; } const provider = new ethers.BrowserProvider(window.ethereum); const signer = await provider.getSigner(); const { chainId } = await provider.getNetwork(); if (parseInt(chainId) !== KITE_TESTNET_CHAIN_ID) { setError("Wrong network! Please switch to Kite Testnet."); return; } const address = await signer.getAddress(); setProvider(provider); setWallet(address); const contractInstance = new ethers.Contract( CONTRACT_ADDRESS, CONTRACT_ABI, signer ); setContract(contractInstance); setError(""); const voted = await contractInstance.hasVoted(address); setHasVoted(voted); const [opt1, opt2] = await contractInstance.getVotes(); setVotes({ option1: Number(opt1), option2: Number(opt2) }); }; const voteForOption = async (option) => { if (!contract || hasVoted) return; try { const tx = option === 1 ? await contract.voteOption1() : await contract.voteOption2(); await tx.wait(); const [opt1, opt2] = await contract.getVotes(); setVotes({ option1: Number(opt1), option2: Number(opt2) }); setHasVoted(true); } catch (err) { setError(err.reason || "Transaction failed"); } }; return (
{error &&

{error}

} {!wallet ? ( ) : (

Wallet: {wallet}

🗳️ Voting

Option 1: {votes.option1} votes

Option 2: {votes.option2} votes

{!hasVoted ? (
) : (

You have already voted!

)}
)}
); } export default App; ``` **Important:** Replace "YOUR\_DEPLOYED\_CONTRACT\_ADDRESS" with the actual contract address you received when deploying your contract from the previous step [Developing Smart Contracts](../3-developing) **Step 3: Run the Frontend** Start your React development server: Copy ``` npm run dev ``` Open your browser and navigate to[ http://localhost:3000](http://localhost:3000/). With MetaMask connected to the KiteAI Testnet, you should see your vote updated on the screen. See Metamask settings for [KITE AI here. ](../3-developing/setup-environment#kite-metamask-settings) Congratulations on building your basic voting dApp on the Kite AI blockchain testnet! You’ve successfully. Github Link & Code - [https://github.com/gokite-ai/kite\_voting\_dapp](https://github.com/gokite-ai/kite_voting_dapp) --- # GoKite Account Abstraction SDK – Developer Guide URL: https://docs.gokite.ai/kite-chain/5-advanced/account-abstraction-sdk The GoKite Account Abstraction (AA) SDK enables developers to build smart contract wallets, manage transactions, and implement rule-based agent spending on the Kite AI Layer 1 chain using ERC-4337 Account Abstraction principles. ## What is the GoKite AA SDK? The SDK provides a simple interface to: - Create and manage Account Abstraction wallets. - Deploy upgradeable vaults for AI agents using proxy contracts. - Set spending rules for token budgets and providers. - Send gasless transactions via bundler integration. - Integrate third-party authentication (Privy, Particle, etc.) for user signing. **Package:** `gokite-aa-sdk` on npm ## Installation ```bash npm install gokite-aa-sdk ``` ## Quick Start ### Initialize the SDK ```typescript import { GokiteAASDK } from 'gokite-aa-sdk'; const sdk = new GokiteAASDK( 'kite_testnet', // Network name 'https://rpc-testnet.gokite.ai', // Kite RPC URL 'https://bundler-service.staging.gokite.ai/rpc/' // Bundler RPC ); ``` ### Get Account Abstraction Wallet Address ```typescript const signer = '0xYourEOAAddress'; const aaWalletAddress = sdk.getAccountAddress(signer); console.log('AA Wallet:', aaWalletAddress); ``` ## Authentication Implement `signFunction` with your preferred wallet/auth SDK: ```typescript // example with ethers: const signFunction = async (userOpHash: string): Promise => { const signer = new ethers.Wallet(process.env.PRIVATE_KEY!); return signer.signMessage(ethers.getBytes(userOpHash)); }; ``` ## Construct and Send User Operation ```typescript // Simple ETH transfer example const sendEthRequest = { target: '0xTargetAddress', value: ethers.parseEther('0.001'), callData: '0x' }; const signFunction = async (userOpHash: string): Promise => { // your sign Function }; const result = await sdk.sendUserOperationAndWait( signerAddress, // your aa signer address sendEthRequest, signFunction ); if (result.status.status === 'success') { console.log('✅ ETH transfer successful!'); console.log('Transaction hash:', result.status.transactionHash); } else { console.log('❌ ETH transfer failed:', result.status.reason); } ``` ## Batch Operation ```typescript const batchRequest = { targets: [ '0xTargetAddress', // ETH recipient '0xERC20Address', // ERC20 token contract for approve '0xERC20Address' // ERC20 token contract for transfer ], values: [ ethers.parseEther('0.01'), // Send 0.01 ETH 0n, // No ETH for approve call 0n // No ETH for transfer call ], callDatas: [ // Operation 1: ETH transfer '0x', // Operation 2: Approve spender to use 1000 tokens ethers.Interface.from(['function approve(address spender, uint256 amount)']).encodeFunctionData('approve', [ '0xSpenderAddress', ethers.parseUnits('1000', 18) // Approve 1000 tokens ]), // Operation 3: Transfer 100 tokens to recipient ethers.Interface.from(['function transfer(address to, uint256 amount)']).encodeFunctionData('transfer', [ '0xRecipient', // Token recipient ethers.parseUnits('100', 18) // Transfer 100 tokens ]) ] }; const signFunction = async (userOpHash: string): Promise => { // your sign Function }; const result = await sdk.sendUserOperationAndWait( signerAddress, // your aa signer address batchRequest, signFunction ); if (result.status.status === 'success') { console.log('Batch operations succeeded!'); console.log('Transaction hash:', result.status.transactionHash); } else { console.log('❌ Batch operations failed:', result.status.reason); } ``` ## Core Features & General Usage ### Deploy ClientAgentVault Proxy Create a secure, upgradeable vault for your agent. ```typescript await sdk.sendUserOperationAndWait(eoa, { target: aaWalletAddress, value: 0n, callData: encodedPerformCreateCallData }, signFunction); ``` - Uses UUPS pattern. - Initializes with settlement token and AA wallet as admin. ### Configure Spending Rules Define budgets & time windows for an agent's transactions. ```typescript const rules = [ { timeWindow: 86400n, // 24 hrs budget: ethers.parseUnits('100', 18), // 100 tokens initialWindowStartTime: startTimestamp, targetProviders: [] } ]; await sdk.sendUserOperationAndWait(eoa, { target: proxyAddress, callData: encodedConfigureSpendingRules }, signFunction); ``` ### Withdraw Funds Move tokens from the vault: ```typescript await sdk.sendUserOperationAndWait(eoa, { target: proxyAddress, callData: withdrawCallData }, signFunction); ``` ### View Rules & Balances (Read-Only) Fetch spending rules: ```typescript const contract = new ethers.Contract(proxyAddress, abi, provider); const rules = await contract.getSpendingRules(); ``` Check token balance: ```typescript const balance = await tokenContract.balanceOf(proxyAddress); ``` ## Useful Addresses on Kite Testnet - **Settlement Token:** `0x0fF5393387ad2f9f691FD6Fd28e07E3969e27e63` - **Settlement Contract:** `0x8d9FaD78d5Ce247aA01C140798B9558fd64a63E3` - **ClientAgentVault Implementation:** `0xB5AAFCC6DD4DFc2B80fb8BCcf406E1a2Fd559e23` ## Resources - **NPM Package:** [gokite-aa-sdk](https://www.npmjs.com/package/gokite-aa-sdk) --- # Advanced Features URL: https://docs.gokite.ai/kite-chain/5-advanced Take your Kite Chain development to the next level with advanced blockchain features and tools. ## What's Covered * [**Account Abstraction SDK**](/kite-chain/5-advanced/account-abstraction-sdk) - Simplify user onboarding with gasless transactions and smart accounts * [**Multisig Wallet**](/kite-chain/5-advanced/multisig-wallet) - Secure multi-signature wallet implementation for team asset management ## Account Abstraction Account Abstraction (ERC-4337) enables: * **Gasless transactions** - Sponsor gas fees for your users * **Social recovery** - Recover accounts without seed phrases * **Batch transactions** - Execute multiple operations in one transaction * **Custom validation logic** - Implement advanced security rules Perfect for improving user experience and removing Web3 friction points. ## Multisig Wallets Multisig wallets provide: * **Shared control** - Require multiple signatures for transactions * **Team treasury management** - Secure funds with distributed authority * **Proposal and voting** - Democratic decision-making for critical operations * **Enhanced security** - No single point of failure Essential for DAOs, teams, and organizations managing significant assets. ## Who This Is For These features are ideal for: * **Product teams** building user-friendly dApps * **DAOs and organizations** managing shared resources * **Advanced developers** implementing sophisticated smart contract patterns * **Projects** requiring enhanced security and UX ## Implementation Patterns Both features can be combined: * Use Account Abstraction for end-user accounts * Implement Multisig for treasury and governance * Create hybrid systems with layered security ## Prerequisites Before diving into advanced features: * Complete [Smart Contract Development](/kite-chain/3-developing) * Build at least one [dApp](/kite-chain/4-building-dapps) * Understand contract deployment and interaction ## Next Steps For production deployments: * Explore [Reference Documentation](/kite-chain/6-reference) for operational details *** _These are advanced topics. Make sure you're comfortable with_ [_basic development_](/kite-chain/3-developing) _first!_ --- # Multisig Wallet URL: https://docs.gokite.ai/kite-chain/5-advanced/multisig-wallet A Safe-style technical guide for GoKite.ai builders & operators that bring all the features of Safe to Kite L1 & Avalanche ecosystem. The Support includes contract deployment, gas estimation, and contract-powered multisig. #### Why Kite + Ash wallet | Category | Kite (Layer-1) | Ash Wallet (Safe Fork) | | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------- | | Purpose | Sovereign, EVM-compatible Layer-1 optimized for AI workloads and Proof of Artificial Intelligence (PoAI). | Battle-tested Safe fork bringing upgradeable, multi-sig smart-accounts to Kite AI for treasury, governance, and agent-ops. | | Native assets | $KITE gas & fee token; AI-agent fees; data & model NFTs. | Secures any ERC-20/721/1155 issued on Kite AI, plus cross-chain bridged assets. | | Core use-cases |
  • DAO & protocol treasury
  • Agent-service escrow
  • Upgrade council
  • Foundation & investor use
|
  • Multi-party control
  • Spending limits
  • Module extensibility
  • Batching & automation
| Ash Wallet gives Kite AI teams the same guarded-control surface Safe users enjoy on Ethereum, now on a high-performance AI chain. #### Key Features (Kite AI Edition) 1. Multi-Signer Smart-Accounts 1. Any n-of-m ownership configuration; change owners or threshold any time. 2. Nonce-protected, replay-safe execution. 2. Optimized Gas Model - Contracts re-compiled against Kite AI’s AVM runtime → lower execution fees than Avalanche C-Chain. 3. Agent-Aware Modules (Roadmap end of 2025) - Pre-built modules for agent stipend streaming, model-licence royalties, and PoAI reward-splitting. 4. LayerZero Bridge Guard - Optional hook that halts outbound transfers until multi-sig quorum approves the destination chain & address. 5. dApp Registry - Curated list of Kite-native DeFi, data pools, and model marketplaces surfaced inside the Apps tab. #### Getting Started #### Prerequisites | Tool | Notes | | -------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | MetaMask ≥ v11 |

Chain name: KiteAI Testnet

Default RPC URL - https://rpc-testnet.gokite.ai/

Chain ID: 2368

Token: KITE

Block Explorer URL - https://testnet.kitescan.ai/

| | $KITE testnet tokens | Get from[ Faucet](https://faucet.gokite.ai) (Testnet Ozone). | | Ash Wallet URL | [https://wallet.ash.center/?network=kite](https://wallet.ash.center/?network=kite) | #### Create a Multisig 1. Connect wallet → Create new Smart Account. 2. Owners: paste each signer’s Kite address (hardware wallets recommended). 3. Threshold: Kite Foundation = 3 of 5; small team = 2 of 3. 4. Review gas (≈ 0.11 $KITE). 5. Deploy – transaction mined on Kite AI L1 in \~1 s. #### Import an Existing Safe / Ash Click “Add existing” → supply multisig address → Ash auto-detects Kite AI contracts; owners need no redeploy. #### Day-to-Day Ops | Task | Flow | | ------------------- | -------------------------------------------------------------------------------- | | Propose token spend | New Tx → Send funds → choose ERC-20 → input amount & recipient → Post. | | Approve | Each owner sees pending tx → Sign → gasless off-chain signature stored. | | Execute | When signatures ≥ threshold, any owner pays gas (can reimburse later). | | Batch agent payouts | New Tx → Contract interaction → select BatchTransfer module → CSV of recipients. | | Upgrade protocol | Use Module → TimelockGuard: delay = 48 h, gives DAO time to veto. | #### Security Best-Practices 1. Hardware keys for all signers. 2. Signer Rotation Playbook – store off-chain; test quarterly. 3. Alert Webhooks → route Ash event logs to Slack/Prometheus. 4. 2-Layer Governance – combine on-chain timelock with off-chain Snapshot vote for non-emergency upgrades. #### Troubleshooting | Symptom | Likely Cause | Fix | | -------------------------------- | ----------------------- | --------------------------------------------- | | Tx stuck in “Awaiting Execution” | Not enough signatures | Ping owners; check threshold. | | “Network not supported” popup | MetaMask on wrong chain | Switch to Kite AI RPC. | | Gas estimate fails | Node lag / mempool full | Retry | | UI missing dApps | Apps list cached | Hard-refresh or Clear dApp cache in settings. | #### Resources * Kite Documentation  * Ash Wallet –[ https://wallet.ash.center/?network=kite](https://wallet.ash.center/?network=kite) * Discord – discord.gg/gokiteai * Contracts –[ ](https://github.com/ash-avax/ash-kite)[https://github.com/safe-global/safe-smart-account/tree/v1.3.0](https://github.com/safe-global/safe-smart-account/tree/v1.3.0) (GPLv3) * SDK – https://github.com/safe-global/safe-core-sdk #### Audit information * [https://github.com/safe-global/safe-smart-account/blob/v1.3.0-libs.0/docs/audit_1_3_0.md](https://github.com/safe-global/safe-smart-account/blob/v1.3.0-libs.0/docs/audit_1_3_0.md) --- # Kite Node URL: https://docs.gokite.ai/kite-chain/7-kite-node This page contains documentation and operational guidance for running and managing nodes on the Kite mainnet. Kite nodes form the backbone of the network. They power consensus, secure transactions, propagate state, and ensure reliable execution for agents, users, and applications built on Kite Chain. --- ## Overview The Kite Node documentation is structured to support both **understanding the network** and **operating production-grade infrastructure**. It is organized into two main sections: 1. [**Mainnet Network Information**](/kite-chain/7-kite-node/mainnet-network-information) 2. [**Mainnet Node Operations**](/kite-chain/7-kite-node/mainnet-node-operations) --- ## What’s Covered ### Mainnet Network Information This section explains how the Kite mainnet works at a protocol and infrastructure level. Topics include: - Network architecture and core components - Validator, full node, and RPC node roles - Chain parameters (block time, gas, limits) - Security details Use this section to understand the system before deploying or integrating nodes. --- ### Mainnet Node Operations This section focuses on hands-on operational guidance for running Kite nodes in production. Topics include: - Hardware and system requirements - Node installation and setup - Configuration and environment tuning - Running and managing node processes - Monitoring, logging, and alerting - Maintenance, upgrades, and recovery Designed for DevOps, SREs, and infrastructure providers. --- ## Who This Is For This documentation is intended for: - Validators participating in Kite network - Infrastructure providers offering RPC or indexing services - DevOps and SRE teams running blockchain infrastructure - Advanced builders requiring protocol-level understanding --- ## Security Good practices Running a node involves private keys, network exposure, and operational risk. Always: - Secure keys and credentials - Restrict network access - Monitor uptime and performance - Apply upgrades carefully and deliberately --- ## Support & Updates - Monitor governance channels for protocol updates - Track documentation changes for operational guidance - Coordinate upgrades during announced network windows --- --- # Mainnet Network Information URL: https://docs.gokite.ai/kite-chain/7-kite-node/mainnet-network-information This page provides the essential network details required to connect to and interact with the **Kite Mainnet**. Use this information when configuring wallets, RPC providers, node clients, or infrastructure services. ## Chain Information | Parameter | Value | |----------------|------------------| | **Chain Name** | KiteAI Mainnet | | **Chain ID** | 2366 | | **Token Symbol** | KITE | ## RPC Endpoints Kite Mainnet provides multiple geographically distributed RPC endpoints for reliability and low latency. It is recommended to configure **multiple RPCs** for redundancy in production environments. ### HTTPS RPCs - Global - [https://rpc.gokite.ai/](https://rpc.gokite.ai/) - Virginia - [https://rpc-virginia.gokite.ai](https://rpc-virginia.gokite.ai) - Tokyo - [https://rpc-tokyo.gokite.ai](https://rpc-tokyo.gokite.ai) - Ireland - [https://rpc-ireland.gokite.ai](https://rpc-ireland.gokite.ai) ### WebSocket (WSS) RPCs - Global - [wss://rpc.gokite.ai/ws](wss://rpc.gokite.ai/ws) - Virginia - [wss://rpc-virginia.gokite.ai/ws](wss://rpc-virginia.gokite.ai/ws) - Tokyo - [wss://rpc-tokyo.gokite.ai/ws](wss://rpc-tokyo.gokite.ai/ws) - Ireland - [wss://rpc-ireland.gokite.ai/ws](wss://rpc-ireland.gokite.ai/ws) WebSocket endpoints are recommended for: - Real-time event subscriptions - Block and transaction streaming - Indexers and agent-based applications ## Block Explorer Use the Kite block explorer to inspect transactions, blocks, contracts, and addresses: - **Explorer:** [https://kitescan.ai/](https://kitescan.ai/) ## Usage Notes - Always use **HTTPS RPCs** for standard JSON-RPC calls - Use **WSS RPCs** for subscriptions and real-time workloads - For production systems, configure **RPC failover** across regions - Monitor governance and upgrade announcements for endpoint changes ## Next Steps - Proceed to **Mainnet Node Operations** to run your own node - Configure wallets and tooling using the Chain ID and RPCs above - Review security best practices before deploying production infrastructure --- # Mainnet Node Operations URL: https://docs.gokite.ai/kite-chain/7-kite-node/mainnet-node-operations This page describes how to set up, configure, deploy, and operate a Kite mainnet node. ## System Requirements ### Minimum Hardware Specifications - **CPU:** 8 AWS vCPU or equivalent - **RAM:** 16GB - **Storage:** 1TB SSD ## Network Requirements Open inbound ports: - **TCP/9650:** HTTP API - **TCP/9651:** P2P Staking ## Prepare Node Config You need to prepare the node config content for `AVAGO_CHAIN_CONFIG_CONTENT` env var. Content must be base64 encoded. The node config options can be found in **C-Chain Configs**. The node config structure is as below, the root key is KiteAI mainnet's blockchain ID, `Config` key is the base64 encoded chain config, `Upgrade` key is the base64 encoded upgrade config. ```json { "3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my": { "Config": "", "Upgrade": "" } } ``` ### Example First, encode the chain config: ```bash echo -n '{"log-level":"trace"}' | base64 ``` This will output something like `ey**********************************`. Then create the full node config JSON and encode it: ```bash echo -n '{"3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my":{"Config":"eyJsb2ctbGV2ZWwiOiJ0cmFjZSJ9",Upgrade":null}}' | base64 ``` It will output `ey***************************************************************X0=`, put this value as `AVAGO_CHAIN_CONFIG_CONTENT` env var when running docker. ## Bootstrap from Snapshot Kite publishes public mainnet chain-data snapshots so you can bootstrap a new node in minutes instead of waiting for a full cold sync (~40 minutes). Each snapshot is a verified archive of `data/db` and `data/chainData`; on first start the node still generates its own identity under `data/staking/`. Download the latest snapshot, verify its checksum, extract it into your `data/` directory, then continue with the deployment steps below (mount the same `data/` volume in your `docker run` command). For the full download, verify, extract, upgrade, and troubleshooting flow, see the [kite-snapshots](https://github.com/gokite-ai/kite-snapshots) repository. Snapshots are served from `https://snapshots.gokite.ai/mainnet/`. ## Deployment ### Standard RPC Node Recommended Chain config: ``` {"eth-apis":["eth","eth-filter","net","web3","internal-eth","internal-blockchain","internal-transaction","internal-debug","internal-account","debug","debug-tracer"],"pruning-enabled":true,"warp-api-enabled":true} ``` Node config: ``` {"3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my": {"Config": "eyJldGgtYXBpcyI6WyJldGgiLCJldGgtZmlsdGVyIiwibmV0Iiwid2ViMyIsImludGVybmFsLWV0aCIsImludGVybmFsLWJsb2NrY2hhaW4iLCJpbnRlcm5hbC10cmFuc2FjdGlvbiIsImludGVybmFsLWRlYnVnIiwiaW50ZXJuYWwtYWNjb3VudCIsImRlYnVnIiwiZGVidWctdHJhY2VyIl0sInBydW5pbmctZW5hYmxlZCI6dHJ1ZSwid2FycC1hcGktZW5hYmxlZCI6dHJ1ZX0", "Upgrade": null}} : eyIzVVNhRWZUY29VaEh4cEtYdnBBRzkxNlVLQ1VFeWpydGtnMmhCQXJCRzNKeURQN215IjogeyJDb25maWciOiAiZXlKbGRHZ3RZWEJwY3lJNld5SmxkR2dpTENKbGRHZ3RabWxzZEdWeUlpd2libVYwSWl3aWQyVmlNeUlzSW1sdWRHVnlibUZzTFdWMGFDSXNJbWx1ZEdWeWJtRnNMV0pzYjJOclkyaGhhVzRpTENKcGJuUmxjbTVoYkMxMGNtRnVjMkZqZEdsdmJpSXNJbWx1ZEdWeWJtRnNMV1JsWW5Wbklpd2lhVzUwWlhKdVlXd3RZV05qYjNWdWRDSXNJbVJsWW5Wbklpd2laR1ZpZFdjdGRISmhZMlZ5SWwwc0luQnlkVzVwYm1jdFpXNWhZbXhsWkNJNmRISjFaU3dpZDJGeWNDMWhjR2t0Wlc1aFlteGxaQ0k2ZEhKMVpYMCIsICJVcGdyYWRlIjogbnVsbH19 ``` Run a standard RPC node using latest tag in the gokite-chain's Github Container Registry with: ``` docker run -d \ --name gokite-chain-rpc-node \ --restart unless-stopped \ -v "$(pwd)/data:/data" \ -u "${CURRENT_UID}:${CURRENT_GID}" \ -p 9650:9650 \ -p 9651:9651 \ -e AVAGO_DATA_DIR=/data \ -e AVAGO_NETWORK_ID=mainnet \ -e AVAGO_HTTP_ALLOWED_HOSTS="*" \ -e AVAGO_HTTP_HOST="0.0.0.0" \ -e AVAGO_PARTIAL_SYNC_PRIMARY_NETWORK=true \ -e AVAGO_PLUGIN_DIR=/plugins/ \ -e AVAGO_HTTP_PORT=9650 \ -e AVAGO_STAKING_PORT=9651 \ -e AVAGO_TRACK_SUBNETS=21uUaTxVdR3Sp6SJhpcSrdH1g66aFoE8mPQDvwKJCjXNexo5y6 \ -e PLUGIN_ID=pJhES6xZkqZxjxMqHiucbpBTTnB97EjL5aTYSynmWBoF26v9e \ -e KITE_CHAIN_ID=3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my \ -e AVAGO_CHAIN_CONFIG_CONTENT= \ ghcr.io/gokite-ai/gokite-chain:latest ``` ### Archive Node #### Recommended Chain config: ```json {"eth-apis":["eth","eth-filter","net","web3","internal-eth","internal-blockchain","internal-transaction","internal-debug","internal-account","debug","debug-tracer"],"pruning-enabled":false,"warp-api-enabled":true} ``` #### Node config: ```json { "3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my": { "Config": "eyJldGgtYXBpcyI6WyJldGgiLCJldGgtZmlsdGVyIiwibmV0Iiwid2ViMyIsImludGVybmFsLWV0aCIsImludGVybmFsLWJsb2NrY2hhaW4iLCJpbnRlcm5hbC10cmFuc2FjdGlvbiIsImludGVybmFsLWRlYnVnIiwiaW50ZXJuYWwtYWNjb3VudCIsImRlYnVnIiwiZGVidWctdHJhY2VyIl0sInBydW5pbmctZW5hYmxlZCI6ZmFsc2UsIndhcnAtYXBpLWVuYWJsZWQiOnRydWV9", "Upgrade": null } } ``` ``: ``` eyIzVVNhRWZUY29VaEh4cEtYdnBBRzkxNlVLQ1VFeWpydGtnMmhCQXJCRzNKeURQN215IjogeyJDb25maWciOiAiZXlKbGRHZ3RZWEJwY3lJNld5SmxkR2dpTENKbGRHZ3RabWxzZEdWeUlpd2libVYwSWl3aWQyVmlNeUlzSW1sdWRHVnlibUZzTFdWMGFDSXNJbWx1ZEdWeWJtRnNMV0pzYjJOclkyaGhhVzRpTENKcGJuUmxjbTVoYkMxMGNtRnVjMkZqZEdsdmJpSXNJbWx1ZEdWeWJtRnNMV1JsWW5Wbklpd2lhVzUwWlhKdVlXd3RZV05qYjNWdWRDSXNJbVJsWW5Wbklpd2laR1ZpZFdjdGRISmhZMlZ5SWwwc0luQnlkVzVwYm1jdFpXNWhZbXhsWkNJNlptRnNjMlVzSW5kaGNuQXRZWEJwTFdWdVlXSnNaV1FpT25SeWRXVjkiLCAiVXBncmFkZSI6IG51bGx9fQ== ``` Run an archive node using latest tag in the gokite-chain's Github Container Registry with: ``` docker run -d \ --name gokite-chain-archive-node \ --restart unless-stopped \ -v "$(pwd)/data:/data" \ -u "${CURRENT_UID}:${CURRENT_GID}" \ -p 9650:9650 \ -p 9651:9651 \ -e AVAGO_DATA_DIR=/data \ -e AVAGO_NETWORK_ID=mainnet \ -e AVAGO_HTTP_ALLOWED_HOSTS="*" \ -e AVAGO_HTTP_HOST="0.0.0.0" \ -e AVAGO_PARTIAL_SYNC_PRIMARY_NETWORK=true \ -e AVAGO_PLUGIN_DIR=/plugins/ \ -e AVAGO_HTTP_PORT=9650 \ -e AVAGO_STAKING_PORT=9651 \ -e AVAGO_TRACK_SUBNETS=21uUaTxVdR3Sp6SJhpcSrdH1g66aFoE8mPQDvwKJCjXNexo5y6 \ -e PLUGIN_ID=pJhES6xZkqZxjxMqHiucbpBTTnB97EjL5aTYSynmWBoF26v9e \ -e KITE_CHAIN_ID=3USaEfTcoUhHxpKXvpAG916UKCUEyjrtkg2hBArBG3JyDP7my \ -e AVAGO_CHAIN_CONFIG_CONTENT= ghcr.io/gokite-ai/gokite-chain:latest ``` ## API Endpoints The node need to track P-Chain before it can be used to query API endpoints, it will take some time to sync. Once bootstrapped, the following API endpoints will be available: - HTTP RPC: http://localhost:9650/ext/bc/21uUaTxVdR3Sp6SJhpcSrdH1g66aFoE8mPQDvwKJCjXNexo5y6/rpc - WebSocket: ws://localhost:9650/ext/bc/21uUaTxVdR3Sp6SJhpcSrdH1g66aFoE8mPQDvwKJCjXNexo5y6/ws ## Health Check Monitor node health status: curl http://localhost:9650/ext/health The node is ready when the response shows "healthy": true. ### Monitor Metrics are available at: - HTTP: http://localhost:9650/ext/metrics ### Data and Keys The data directory is located at $(pwd)/data. If you want to use a different directory, you can change the -v "$(pwd)/data:/data" option in the deployment command. The keys are randomly generated and stored in the directory under the data/staking directory. If you are running the node for validator, you may want to backup the keys. ### Run the Node Manually All the configurations and commands to build the docker image are in the this repository. If you want to run the node manually without using docker, feel free to check github actions to see how to build and run the node. --- # Stablecoin workflow and User Experience URL: https://docs.gokite.ai/kite-chain/8-kite-stablecoin/stablecoin-gasless-transfer This section describes how users interact with Kite Chain tokens under both **normal (gas-paid)** and **gasless (meta-transaction)** transfer flows, along with the backend API interface, integration scenarios, reference smart contract implementation, and security considerations. ## Normal Transfer In a normal transfer flow, the token behaves like a standard ERC-20 token. ### Flow 1. The user signs a standard ERC-20 `transfer` transaction. 2. The transaction is sent directly to the Kite Chain RPC endpoint. 3. The transaction is executed on-chain. ### Key Characteristics - Fully compatible with all standard ERC-20 wallets. - No additional infrastructure is required. - **Gas fees are paid by the user**. - Ideal for power users, DeFi integrations, and direct on-chain interactions. ## Gasless Transfer Gasless transfers use **EIP-712 typed data signatures** and **EIP-3009-style authorizations**, allowing a third party to pay gas on behalf of the user. ### Flow 1. The user signs a `TransferWithAuthorization` message using EIP-712. 2. The signed message is sent to a backend relayer service. 3. The backend service: - Verifies the signature and authorization state. - Composes the on-chain transaction. 4. The backend submits the transaction to the Kite Chain RPC endpoint. 5. The backend returns the transaction hash to the user. 6. The user monitors the transaction status using the returned hash. ### Key Characteristics - No native token balance required by the user. - **Gas fees are paid by the backend service**. - Ideal for: - Consumer-facing wallets - Web2-style UX - Agent-based and automated payments - Stablecoin-first onboarding ## API Interface ### Request Example ```json { "from": "0x**********************************", "to": "0x**********************************",", "value": "1234567890123456", "validAfter": "1234567891", "validBefore": "1234567892", "nonce": "0x**********************************", "v": 28, "r": "0x**********************************", "s": "0x**********************************" } ``` ### Response Example ```json { "txHash": "0x**********************************" } ``` ## User Scenarios Kite Chain supports multiple relayer deployment models to accommodate different scale, security, and user-experience requirements. ### Public Relayer (Default) Kite operates a public backend relayer service as shared infrastructure for the ecosystem. **Characteristics** - Kite runs the backend service as public infrastructure. - Any user can submit gasless transfer requests. - Built-in security controls are enforced to prevent abuse and DDoS attacks. **Best For** - End users - Wallet integrations - Consumer-facing applications ### Private Relayer (Partner-Hosted) Ecosystem partners can operate their own private backend relayer service. **Characteristics** - Partners (wallets, DeFi protocols, AI agents, platforms) run their own backend service. - Full control over relayer logic, policies, and operational parameters. - Custom security rules tailored to specific business or product needs. **Best For** - High-volume platforms - Custom UX and application-specific flows - Protocol- or platform-owned gas sponsorship models ## Stablecoin Smart Contract Reference Implementation The following reference implementation demonstrates an ERC-20 stablecoin with EIP-3009-style authorization support: ``` // SPDX-License-Identifier: MIT pragma solidity ^0.8.20; import "@openzeppelin/contracts/token/ERC20/ERC20.sol"; import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol"; import "@openzeppelin/contracts/utils/cryptography/EIP712.sol"; /** * @title PYUSD * @notice ERC20 token that supports EIP-3009 meta-transactions using OpenZeppelin primitives. */ contract PYUSD is ERC20, EIP712 { enum AuthorizationState { Unused, Used, Canceled } mapping(address => mapping(bytes32 => AuthorizationState)) private _authorizationStates; bytes32 private constant _TRANSFER_WITH_AUTHORIZATION_TYPEHASH = keccak256( "TransferWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)" ); bytes32 private constant _RECEIVE_WITH_AUTHORIZATION_TYPEHASH = keccak256( "ReceiveWithAuthorization(address from,address to,uint256 value,uint256 validAfter,uint256 validBefore,bytes32 nonce)" ); bytes32 private constant _CANCEL_AUTHORIZATION_TYPEHASH = keccak256("CancelAuthorization(address authorizer,bytes32 nonce)"); event AuthorizationUsed(address indexed authorizer, bytes32 indexed nonce); event AuthorizationCanceled(address indexed authorizer, bytes32 indexed nonce); constructor(address initialHolder, uint256 initialSupply) ERC20("PYUSD", "PYUSD") EIP712("PYUSD", "1") { _mint(initialHolder, initialSupply); } function DOMAIN_SEPARATOR() external view returns (bytes32) { return _domainSeparatorV4(); } function authorizationState(address authorizer, bytes32 nonce) external view returns (AuthorizationState) { return _authorizationStates[authorizer][nonce]; } function transferWithAuthorization( address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s ) external { _transferWithAuthorization( _TRANSFER_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce, v, r, s ); } function receiveWithAuthorization( address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s ) external { require(msg.sender == to, "PYUSD: caller must be payee"); _transferWithAuthorization( _RECEIVE_WITH_AUTHORIZATION_TYPEHASH, from, to, value, validAfter, validBefore, nonce, v, r, s ); } function cancelAuthorization( address authorizer, bytes32 nonce, uint8 v, bytes32 r, bytes32 s ) external { _requireUnusedAuthorization(authorizer, nonce); bytes32 structHash = keccak256( abi.encode(_CANCEL_AUTHORIZATION_TYPEHASH, authorizer, nonce) ); address signer = ECDSA.recover(_hashTypedDataV4(structHash), v, r, s); require(signer == authorizer, "PYUSD: invalid signature"); _authorizationStates[authorizer][nonce] = AuthorizationState.Canceled; emit AuthorizationCanceled(authorizer, nonce); } function _transferWithAuthorization( bytes32 typeHash, address from, address to, uint256 value, uint256 validAfter, uint256 validBefore, bytes32 nonce, uint8 v, bytes32 r, bytes32 s ) private { require(block.timestamp > validAfter, "PYUSD: authorization not yet valid"); require(block.timestamp < validBefore, "PYUSD: authorization expired"); _requireUnusedAuthorization(from, nonce); bytes32 structHash = keccak256( abi.encode(typeHash, from, to, value, validAfter, validBefore, nonce) ); address signer = ECDSA.recover(_hashTypedDataV4(structHash), v, r, s); require(signer == from, "PYUSD: invalid signature"); _authorizationStates[from][nonce] = AuthorizationState.Used; emit AuthorizationUsed(from, nonce); _transfer(from, to, value); } function _requireUnusedAuthorization(address authorizer, bytes32 nonce) private view { require( _authorizationStates[authorizer][nonce] == AuthorizationState.Unused, "PYUSD: authorization state not unused" ); } } ``` ## Security Considerations ### Preventing DDoS Attacks Gasless transfers introduce an additional attack surface because transaction gas fees are paid by the relayer rather than the end user. Without safeguards, a relayer can be spammed with signed messages that consume infrastructure resources and on-chain gas. To mitigate this risk, the backend relayer service must enforce strict validation and rate-limiting controls before submitting any transaction on-chain. ### Potential Protection Rules The following protections can be applied individually or in combination: - **Rate limiting per IP address** Limits the number of requests originating from a single IP within a given time window. - **Rate limiting per user address** Caps the number of gasless transfers a single wallet can submit over time. - **Minimum token balance requirement** Requires the sender to hold at least a minimum balance (e.g. ≥ 10 PYUSD) before a gasless transfer is accepted. - **Signature expiration windows** Enforces short validity periods to prevent replay or delayed execution. - **Per-address daily transfer caps** Limits the total value or number of gasless transfers per address per day. - **Optional allowlists or reputation scoring** Enables preferential access for trusted users, applications, or agents, while restricting unknown or low-reputation actors. ### Deployment Flexibility These security rules are configurable and can be tuned based on the relayer deployment model: - **Public relayers** typically enforce stricter limits and conservative thresholds. - **Private or partner-operated relayers** can apply customized rules aligned with their UX, volume, and risk tolerance. This layered approach ensures gasless transfers remain secure, reliable, and economically sustainable across the Kite Chain ecosystem. Source: - EIP 3009: https://eips.ethereum.org/EIPS/eip-3009 --- # Allowance and sessions URL: https://docs.gokite.ai/passport/payments/allowance Your agent pays for a call in one of two ways. Both are budgets you approve with your passkey. ## Allowance vs. session - **Allowance:** one budget for all your agents. It renews every week or month, so you approve only once. - **Session:** a budget for one task, with its own limit and end date. Use it when you want tighter control. ## Compare | | Allowance | Session | | --- | --- | --- | | What it is | One budget for all your agents | A budget for one task | | Renews | Every week, 2 weeks or month | Never; it ends when used up or expired | | Passkey approvals | Once, when you set it up | For every new session | | Limits | A total per period, up to 100 USD | Per payment and in total, plus an end date | | Pays for | Paid API calls | Paid API calls and shopping checkouts | | Best for | Everyday paid calls without interruptions | Tighter control of one task, or a larger one-off spend | ## Which one to use Use an allowance for routine paid API calls you don't want to approve one by one. Use a session when you want: - A hard cap per payment. - A fixed end date. - A budget for one specific task. - A spend above your allowance. Shopping checkouts always use a session. Many users use both. ## Who pays a call - While a session you approved is active, it pays. - When that session is used up, your agent stops and asks you. - When it has expired, or there is no session, the allowance pays with no prompt. - If the allowance can't pay (not set, used up for this period, or too small), your agent tells you and asks before requesting a session. ## Turn on your allowance One budget for all your agents, renewed every week or month, approved once. 1. Open the Passport dashboard Home at [agentpassport.ai/overview](https://agentpassport.ai/overview). 2. Click **Allowance · Set up** at the top of Live sessions, or **Set up allowance** on the card. 3. Enter an amount. The most you can set is 100 USD. 4. Pick **Weekly**, **Every 2 weeks** or **Monthly**. 5. Tick **Covers my current and future agents**. 6. Click **Approve** and confirm with your passkey. Without a passkey, create one first. See [Install Passport](/passport/install). Home then shows the money left and the reset date. Turn agents on or off, or cancel the allowance, under **Manage**. Agents spend from your Passport balance up to the allowance. An empty balance stops payments even when an allowance is set. See [Funding your wallet](/passport/payments/funding). Allowance is live mode only. It is not available in sandbox. ## Use a session A session covers one task. You approve it once, and it pays until it runs out or expires. 1. Your agent requests a session with the limits it needs: ```bash kpass session create \ --task-summary "Make one weather API call" \ --max-amount-per-tx 2 \ --max-total-amount 10 \ --ttl 24h \ --assets USDC \ --output json ``` 2. The command returns an approval link. Open it on any device where your passkey lives and approve the session. 3. The session pays for your agent's calls until it runs out of budget or expires. For the full payment flow, see [Payments](/passport/payments). --- # Funding Your Wallet URL: https://docs.gokite.ai/passport/payments/funding To use Kite Passport, you need **USDC.e on Kite chain** in your Passport wallet. Once your wallet is funded, your agent can pay for services on your behalf within the limits you approve. ## Adding Funds All funding is managed through the **Passport dashboard**. ### Buy USDC with Card The simplest path if you are starting from scratch. Purchase USDC on Base using a card. **Steps:** 1. Open the Passport dashboard and select the **Add funds** tab. ![](/images/kite-agent-passport/funding/add-funds-onramp.png) 2. Click **Continue**. 3. Enter the amount you want to purchase and select your payment method. 4. Follow the steps to complete the purchase. 5. Once the purchase settles, your balance will update on the Passport dashboard. ### Direct Deposit If you already hold stablecoins on another chain, you can deposit them directly to your Passport wallet. **Steps:** 1. Open the **Crypto** tab to see your Passport deposit addresses: Base USDC, Polygon USDC, Avalanche USDC, Tempo USDC, Solana USDC or PYUSD, Robinhood USDG, Arc USDC, Kite USDC (this token is USDC.e on Kite chain). ![](/images/kite-agent-passport/funding/add-funds-bridge.png) > Only the stablecoin shown, on that chain. 2. Click the copy button next to the address for the chain your funds are on. ![](/images/kite-agent-passport/funding/copy-wallet-address.png) 3. Send that chain's stablecoin to the address from your own wallet. 4. Your balance will update automatically on the Passport dashboard. #### Kite Bridge (Optional) You can also use [Kite Bridge](https://bridge.gokite.ai) to move USDC onto Kite chain. **Steps:** 1. Go to [Kite Bridge](https://bridge.gokite.ai) and connect the wallet that holds your funds. 2. Select the source chain and token. 3. Select Kite as the destination chain. 4. Paste your Passport wallet address as the receiver. ![](/images/kite-agent-passport/funding/06-kite-bridge.png) 5. Confirm both transaction popups. 6. Wait about 1 minute for the bridge to complete. 7. Your balance will update automatically on the Passport dashboard. ### Transfer from Your Own Wallet on Kite If you already have funds in your own wallet on Kite chain, you can transfer them to your Passport wallet. **Steps:** 1. Copy your Passport wallet address from the **Crypto** tab in the dashboard. ![](/images/kite-agent-passport/funding/copy-wallet-address.png) 2. Open your external wallet (such as MetaMask). Click **Send**, choose USDC.e on Kite chain, and paste your Passport wallet address. ![](/images/kite-agent-passport/funding/metamask-usdc-kite.png) 3. Send the USDC.e to your Passport wallet address. 4. Confirm the transfer has landed on the dashboard. > **Note:** You will need KITE tokens for gas fees on Kite chain to execute the transfer. ## Checking Your Balance You can check your Passport wallet balance at any time: - **Dashboard** — the balance is shown on the main screen - **CLI** — run `kpass wallet balance` (use `--cached` for the 30-second cached balance) - **Ask your agent** — it can check the balance for you You can also view your deposit addresses with `kpass wallet address --chain `. ## Troubleshooting ### Balance not showing after funding - **Bought with card** — settlement can take some time depending on the payment provider and method. Check back on the dashboard. - **Direct deposit** — make sure you sent the correct stablecoin for that chain to the address. - **Kite Bridge** — wait for the bridge transaction to confirm, then check the dashboard. --- # Payments URL: https://docs.gokite.ai/passport/payments ## Pay for a service Your agent can pay for services on Kite once Passport is set up and your wallet is funded. The agent discovers paid services in the catalog, pays from your allowance or from a spending session you approve, and you check the transaction in your activity. The whole flow takes a few steps: 1. **Set up Passport for your agent.** Follow [Install Passport](/passport/install) for your coding agent or cloud agent, then come back here. 2. **Fund your wallet.** Your Passport wallet needs USDC.e on Kite chain before your agent can spend. See [Funding your wallet](/passport/payments/funding) for how to add funds by card, direct deposit, or Kite Bridge. 3. **Search the catalog** for a service that fits your need: ```bash ksearch service list \ --query weather \ --asset USDC \ --limit 10 \ --output json ``` Or ask your agent: *"Show me all the weather services available on Kite Passport."* 4. **Pay from your allowance, or create a session.** When you have an [allowance](/passport/payments/allowance), paid calls come out of it with no prompt. Use a spending session for tighter control of one task, or for a shopping checkout. A session is also what you create when the CLI tells you the allowance can't pay. Your agent requests a session like this: ```bash kpass session create \ --task-summary "Make one weather API call" \ --max-amount-per-tx 2 \ --max-total-amount 10 \ --ttl 24h \ --assets USDC \ --output json ``` This returns an approval URL. Open it on any device where your passkey lives and approve the request. The session is active once you approve it. Your agent can then spend up to the total limit without asking again, until the session expires or runs out of budget. See [Allowance and sessions](/passport/payments/allowance) to compare the two and pick one. ![Approve the session request](/images/kite-agent-passport/beginner-setup/07-session-request.png) 5. **Make a paid call** to a service: ```bash kpass session execute \ --url "https://api.example.com/weather?location=San%20Francisco" \ --method GET \ --output json ``` The request is paid with USDC according to the service's x402 pricing, and your agent receives the response. 6. **Check your activity.** Review completed payments and session spending on the Passport dashboard at [agentpassport.ai/dashboard](https://agentpassport.ai/dashboard). ![Activity on the Passport dashboard](/images/kite-agent-passport/payments/dashboard-activity.png) You can also list active sessions with: ```bash kpass session list --status active --output json ``` Or view recent activity: ```bash kpass activity --limit 20 --output json ``` ### Example prompt Give your agent a complete prompt like this to handle the whole flow: > I need to use a weather API through Kite Passport. Search the catalog for weather services, create a spending session with a $5 total budget and $1 per-transaction limit valid for 2 hours, make one call to get the weather for San Francisco, and show me the response. Your agent uses the installed Kite Passport skills to run the search, request the session (which you approve with your passkey), execute the paid call, and report back. To see a live example, open the [Passport Playground](https://agentpassport.ai/playground), or browse paid services on [Explore](https://agentpassport.ai/explore). --- # Blockchain Fundamentals URL: https://docs.gokite.ai/kite-chain/2-fundamentals/blockchain-fundamentals ## What is a Blockchain? A blockchain is a distributed, decentralized digital ledger that records transactions across a network of computers. Think of it as a chain of blocks, where each block contains a list of transactions. Once a block is added to the chain, it becomes permanent and cannot be altered. ## Key Characteristics ### 1. Decentralization - No single point of control or failure - Network is distributed across multiple nodes - Each node maintains a copy of the entire blockchain ### 2. Immutability - Once data is written to the blockchain, it cannot be changed - Historical records are permanent and tamper-proof - Provides a high level of data integrity ### 3. Transparency - All transactions are visible to all participants - Anyone can verify the authenticity of transactions - Public blockchains are completely transparent ### 4. Security - Uses cryptographic techniques to secure data - Consensus mechanisms prevent malicious attacks - Digital signatures ensure transaction authenticity ## How Blockchains Work ### 1. Transaction Creation When a user wants to make a transaction, they create a digital message containing: - Sender's address - Recipient's address - Amount to transfer - Digital signature ### 2. Transaction Validation - Network nodes verify the transaction - Check if sender has sufficient funds - Validate digital signature - Ensure transaction format is correct ### 3. Block Formation - Valid transactions are grouped into blocks - Each block contains a header with metadata - Previous block's hash is included (creating the chain) ### 4. Consensus - Network nodes must agree on which block to add next - Different consensus mechanisms (Proof of Work, Proof of Stake, etc.) - Prevents double-spending and ensures network security ### 5. Block Addition - Once consensus is reached, block is added to chain - All nodes update their local copy - Transaction is now confirmed and permanent ## Types of Blockchains ### Public Blockchains - Open to anyone (Bitcoin, Ethereum) - Fully decentralized - Transparent and permissionless - Anyone can participate in consensus ### Private Blockchains - Controlled by a single organization - Faster transaction processing - More privacy and control - Permissioned access ### Consortium Blockchains - Controlled by a group of organizations - Semi-decentralized - Shared governance model - Used in enterprise applications ## Common Use Cases 1. **Cryptocurrencies**: Digital money (Bitcoin, Ethereum) 2. **Smart Contracts**: Self-executing agreements 3. **Supply Chain**: Tracking goods from origin to destination 4. **Identity Management**: Secure digital identities 5. **Voting Systems**: Transparent and tamper-proof voting 6. **Asset Tokenization**: Converting real assets to digital tokens ## Benefits of Blockchain Technology - **Trust**: Eliminates need for intermediaries - **Security**: Cryptographic protection against fraud - **Transparency**: All transactions are visible and verifiable - **Efficiency**: Reduces costs and processing times - **Global Access**: Anyone with internet can participate ## Challenges - **Scalability**: Limited transaction processing speed - **Energy Consumption**: Some consensus mechanisms require significant energy - **Regulation**: Evolving legal and regulatory frameworks - **User Experience**: Complex interfaces for non-technical users - **Interoperability**: Different blockchains don't easily communicate --- *Understanding these fundamentals is crucial for developing on any blockchain platform, including Kite. The concepts you learn here will form the foundation for more advanced topics.* --- # Blockchain Fundamentals URL: https://docs.gokite.ai/kite-chain/2-fundamentals If you're new to blockchain development, this section covers the foundational concepts you need to understand before building on Kite Chain. ## What You'll Learn - **[Blockchain Basics](/kite-chain/2-fundamentals/blockchain-fundamentals)** - Understanding distributed ledgers, consensus, and blockchain architecture - **[Smart Contract Basics](/kite-chain/2-fundamentals/smart-contract-basics)** - How programmable logic works on blockchains and key concepts ## Topics Covered ### Blockchain Fundamentals - Core concepts of blockchain technology - Cryptography basics and how they secure networks - Consensus mechanisms and how blockchains achieve agreement - Transaction lifecycle and block formation ### Smart Contracts - What smart contracts are and how they work - Solidity programming language basics - Contract deployment and interaction - Common patterns and best practices - Security considerations ## Who This Is For This section is designed for developers of all skill levels: - **Complete beginners** - Start here to build a strong foundation - **Experienced developers** - Refresh your knowledge of blockchain concepts - **Web2 developers** - Transition to Web3 development with clear explanations ## Next Steps After completing the fundamentals: 1. Move to [Developing Smart Contracts](/kite-chain/3-developing) to write your first contract 2. Build complete [dApps](/kite-chain/4-building-dapps) with user interfaces 3. Explore [Advanced Features](/kite-chain/5-advanced) like account abstraction --- *Already familiar with blockchain? Skip to [Developing on Kite](/kite-chain/3-developing)!* --- # Smart Contract Basics URL: https://docs.gokite.ai/kite-chain/2-fundamentals/smart-contract-basics ## Introduction Smart contracts are the building blocks of decentralized applications (dApps). They enable programmable logic on blockchain networks, allowing for trustless and automated execution of agreements. This guide covers the fundamentals of smart contract development and interaction. ## What are Smart Contracts? Smart contracts are self-executing programs that run on blockchain networks. They automatically execute predefined actions when specific conditions are met, without requiring intermediaries or third parties. Think of smart contracts as digital agreements that: - Execute automatically when conditions are satisfied - Are stored on the blockchain (immutable and transparent) - Cannot be altered once deployed - Reduce the need for trust between parties ## How Smart Contracts Work ### 1. Contract Creation - Developer writes code in a smart contract language (Solidity, Rust, etc.) - Code defines the contract's logic and conditions - Contract is compiled into bytecode ### 2. Contract Deployment - Contract is uploaded to the blockchain - Receives a unique address - Becomes immutable and permanent - Requires gas fees for deployment ### 3. Contract Interaction - Users can call functions on the contract - Each interaction requires gas fees - Contract executes based on its programmed logic - Results are recorded on the blockchain ## Key Features ### Immutability - Once deployed, contract code cannot be changed - Ensures trust and predictability - Requires careful testing before deployment ### Transparency - All contract code is publicly visible - Anyone can audit the contract - Builds trust in the system ### Automation - No human intervention required - Reduces errors and delays - Ensures consistent execution ### Decentralization - Runs on distributed network - No single point of failure - Resistant to censorship ## Common Smart Contract Use Cases ### 1. Token Creation - **ERC-20 tokens** (fungible tokens) - **ERC-721 tokens** (NFTs) - **ERC-1155 tokens** (multi-token standard) - Custom token standards ### 2. DeFi Protocols - **Decentralized exchanges (DEXs)** - **Lending platforms** - **Yield farming protocols** - **Automated market makers (AMMs)** ### 3. Gaming - In-game assets and currencies - Player ownership of digital items - Provably fair games - Play-to-earn mechanics ### 4. Supply Chain - Product tracking and verification - Authenticity verification - Automated compliance - Transparent logistics ### 5. Voting Systems - Decentralized governance - Transparent voting processes - Automated result execution - DAO governance ## Smart Contract Languages ### Solidity (Ethereum) - Most popular smart contract language - Similar to JavaScript - Extensive documentation and community - Used on Ethereum and EVM-compatible chains **Learn more:** [Solidity Documentation](https://docs.soliditylang.org/) There are also other development languages in the blockchain world like **Rust** used by Solana, Polkadot, Cosmos and NEAR, and **Move** used by Aptos and Sui. **Vyper** is another Ethereum language with Python-like syntax focused on security and simplicity. ## Smart Contract Development Lifecycle ### 1. Planning - Define contract requirements - Design contract architecture - Plan gas optimization - Security considerations ### 2. Development - Write contract code - Implement business logic - Add security measures - Follow best practices ### 3. Testing - Unit testing - Integration testing - Security auditing - Testnet deployment ### 4. Deployment - Mainnet deployment - Contract verification - Documentation - Community review ### 5. Maintenance - Monitor contract performance - Handle upgrades (if possible) - Community support - Bug fixes ## Security Considerations ### Common Vulnerabilities - **Reentrancy**: Contract calls itself before completing - **Integer Overflow**: Mathematical operations exceed limits - **Access Control**: Unauthorized access to functions - **Gas Limits**: Functions that consume too much gas - **Front-running**: MEV attacks and sandwich attacks ### Best Practices - Follow established patterns and standards - Use battle-tested libraries - Implement proper access controls - Conduct thorough testing - Get professional audits - Use formal verification tools ## Gas and Transaction Costs ### What is Gas? - Computational cost of executing operations - Paid in the blockchain's native token - Prevents spam and abuse - Incentivizes efficient code ### Gas Optimization - Minimize storage operations - Use efficient data structures - Batch operations when possible - Avoid unnecessary computations ## Interacting with Smart Contracts ### Reading Data - Free operations (no gas cost) - Can be done by anyone - Examples: token balances, contract state - Uses RPC calls ### Writing Data - Requires gas fees - Creates transactions - Examples: transferring tokens, calling functions - Requires wallet signature ### Tools for Interaction - **Web3 libraries** (web3.js, ethers.js) - **Block explorers** (Etherscan, Polygonscan) - **Wallet applications** (MetaMask, WalletConnect) - **Development frameworks** (Hardhat, Truffle) ## Smart Contract Patterns ### Access Control - Owner-only functions - Role-based permissions - Multi-signature wallets - Timelock contracts ### Upgradeable Contracts - Proxy patterns - Diamond pattern - Storage separation - Version management ### Gas Optimization - Batch operations - Efficient data structures - Minimal storage usage - Loop optimization ## Testing and Deployment ### Local Development - Use development networks - Test with local blockchain - Debug with tools like Hardhat - Simulate different scenarios ### Testnet Deployment - Deploy to test networks - Test with real transactions - Verify contract behavior - Security testing ### Mainnet Deployment - Final security audit - Gas optimization - Contract verification - Documentation --- *Smart contracts are the foundation of decentralized applications (dApps). Understanding how they work is essential for building on any blockchain platform, including Kite. The concepts covered here provide the fundamental knowledge needed to develop secure and efficient smart contracts.* --- # Merchant fee estimates in session preflight URL: https://docs.gokite.ai/changelog/2026/2026-05-19-backend-v1-1-0 ## What changed When an agent constructs a session delegation, the preflight call now returns an `estimated_fees` object covering the catalog's known merchant fees, network gas, and Passport's own service margin. Approval pages can show users an itemized "up to ~$X" total instead of just a raw budget cap. This estimate is informational only — actual fees still come from the merchant at transaction time — but it makes high-budget sessions less surprising and reduces post-approval support questions. **Included changes:** - feat(session): return estimated_fees in preflight response - feat(catalog): track per-service fee metadata --- # Filter activity by date and merchant URL: https://docs.gokite.ai/changelog/2026/2026-05-19-cli-v1-3-4 ## What changed The `kpass activity` command previously returned the full event history with no way to narrow the result set. Agents asking "what did I spend on Amazon last week?" had to fetch everything and filter locally, which was slow on accounts with many sessions. You can now pass `--since YYYY-MM-DD`, `--until YYYY-MM-DD`, and `--merchant ` to filter on the server side. Results are paginated, and the JSON envelope adds a `truncated: true` flag when the result set hits the page limit. **Included changes:** - feat(activity): add --since/--until/--merchant flags - fix(activity): respect --output json with truncation indicator --- # request-session retries preflight on catalog errors URL: https://docs.gokite.ai/changelog/2026/2026-05-19-skills-v0-9-1 ## What changed `request-session` previously treated any non-200 response from the catalog preflight as a hard failure, which meant transient catalog blips would abort otherwise-valid session approvals. The skill now retries 503 and timeout responses up to three times with exponential backoff before propagating the error. Approval cancellations attributable to catalog flakiness should drop noticeably. Permanent errors (404 service-not-found, 403 unauthorized) are still surfaced immediately so agents don't waste time retrying. **Included changes:** - feat(request-session): retry preflight on 503/timeout - docs(request-session): document the retry behavior in SKILL.md --- # Estimated fees on session approval URL: https://docs.gokite.ai/changelog/2026/2026-05-19-web-v1-2-0 ## What changed The session approval page now renders the new `estimated_fees` field from the backend preflight. Users see the budget cap and an itemized "up to ~$X" estimate covering merchant fees, network gas, and Passport's service margin. The estimate is labeled as informational; the underlying budget cap still controls actual spending. We added a small "what counts as a fee?" tooltip to explain the breakdown. **Included changes:** - feat(approval): render estimated_fees breakdown - feat(approval): add fee-breakdown tooltip --- # Submit agent feedback from the CLI URL: https://docs.gokite.ai/changelog/2026/2026-05-27-cli-1-3-20 ## What changed The CLI now exposes a `kpass feedback submit` command that allows agents to send structured feedback without leaving the terminal. This is useful for programmatic reporting — an agent can flag a failed payment, unexpected behavior, or a feature request as part of its normal workflow. The command accepts a message payload and returns a confirmation from the server. A new `cmd/agent/feedback/` package handles input validation and the submission flow, while the API client layer has been extended with a dedicated feedback endpoint. The existing `kpass help` output has been updated to surface the new subcommand. **Included changes:** - feat: added agent feedback (#49) ([#49](https://github.com/gokite-ai/passport-cli/pull/49)) --- # Internal changelog workflow and dependency updates URL: https://docs.gokite.ai/changelog/2026/2026-05-28-cli-v1-3-21 ## What changed This release introduces a `changelog-on-release` GitHub Actions workflow that automates changelog entry generation when a new release tag is pushed. A Dependabot configuration file is also added to manage future automated dependency updates.\n\nThe only other changes are a patch bump to the npm package version and its corresponding lock file update. No CLI commands, flags, API client behavior, or output formats were modified. **Included changes:** - fix: bump version to 1.3.21 (#55) ([#55](https://github.com/gokite-ai/passport-cli/pull/55)) - fix(changelog): address code review comments - feat(changelog): update changelog workflow - feat: add changelog workflow --- # Passkey security overhaul: step-up, recovery, login history, USD session caps URL: https://docs.gokite.ai/changelog/2026/2026-06-04-backend-v1-3-0 ## What changed High-risk actions now require a fresh passkey assertion bound to the exact operation. `wallet.send`, `agent_session.approve`, `passkey.register.additional`, and `passkey.remove` each have a `/stepup` preflight that issues an HMAC token committing to action type, target resource, and a canonical parameter hash; the WebAuthn challenge is set to `SHA-256(token)` and a persisted step-up session prevents replay. Each enforcement point has a `Disable*StepUp` config flag for operator rollback, and all four step-ups emit activity events that drive a new `GET /v1/security/stepup-log` audit endpoint (filterable by `all`, `agent_approve`, `wallet`, `passkey`). Agent session caps are now USD-denominated. The `Assets` token allowlist is gone from session delegation — the agent never names a settlement token. Sessions carry a server-stamped `Currency` field (default `USD`), and the merchant chooses the settlement stablecoin at transaction time. Tool params and swagger have been reworded to USD/budget language; CLI and skill USD changes follow separately. Account recovery for the lost-passkey case ships behind `POST /v1/recovery/{start,cancel,complete}` and `GET /v1/recovery/status`. `start` flips the account to `recovery_pending` (which `GetUserPasskeyReadiness` exposes, naturally blocking high-risk actions), `complete` enforces a configurable delay (72h prod default, 10m in nonprod) and atomically revokes credentials plus other auth sessions in a single transaction. The recovery-started email carries a one-shot HMAC cancel link bound to the user and `RecoveryStartedAt`; clicking it lands on a confirmation page and cancellation happens via explicit POST so link previews and prefetch can't silently cancel. All five lifecycle events (passkey added/disabled, cooldown started, recovery started/completed) now render through a shared branded HTML template with a plain-text fallback. A `login_events` table now records every `/v1/login/verify` attempt with derived device, browser, and MaxMind-resolved city/country (IP is not stored). Users can read their own history via `GET /v1/security/login-log` with `since`/`until`/`limit`/`offset` and a 90-day default. On top of this, first-passkey enrollment now evaluates risk: when the registering session's device, browser, and country are all unseen versus the user's prior successful logins, enrollment is held (`403 ErrPasskeyEnrollmentRiskHold` at `POST /v1/passkey/register/options`, before WebAuthn options are returned) and a security email is sent. The hold lifts on a familiar re-login or after the cooldown window. `GET /v1/passkey` lists a user's credentials with a richer display name (`Platform passkey (synced, built-in) @ Mac · Chrome`), and `POST /v1/passkey/delete` soft-disables credentials so they stay in the audit trail but no longer count toward readiness. `GET /v1/me` now surfaces `passkey_readiness` so clients can drive gating from a single call. Both `login_events` and `first_passkey_risk` are gated by config flags and ship enabled in `base.yaml`; the GeoLite2-City database is bundled into the Docker image. **Included changes:** - refactor(agent): make session caps USD-denominated, drop token allowlist - chore(config): shorten recovery & first-passkey-risk cooldowns to 10m in nonprod - fix: address security review findings - feat(passkey): richer display name with humanized transports - docs(passkey): align login-history web surface with implemented columns - docs(recovery): align cancel-email subject with confirm flow + document GET landing - fix(recovery): require explicit POST to cancel recovery via email link - docs(passkey): correct stale step-up challenge comment and risk-hold endpoint - feat(passkey): derive and expose passkey display metadata - fix(recovery): accept cancel links without started_at - feat(security): brand security notification emails with shared HTML template - fix(passkey): use singular login_event table name in partial index migration - fix(passkey): review nits — empty cancel-URL fallback, doc comment, docs - fix(passkey): run first-passkey risk gate before the step-up check - fix(passkey): bind first-passkey risk to the exact session + gate at begin - docs(passkey): align remaining design docs with implemented risk model - feat(passkey): implement first-passkey enrollment risk hold + enable flags - fix(recovery): claim recovery atomically before destructive revoke - login_events: fix dev startup - default tag must quote the literal, make migration self-healing - config: add stepup + recovery default stanzas to base.yaml - login_events: review followups - close geoip on stop, partial email index, rune-safe truncate - login_events: P1/P2 review fixes (defaults, EOF whitespace, evaluator ctx) - go mod tidy: promote useragent + geoip2 to direct deps - login_events: schema + ingestion + GET /v1/security/login-log + first-passkey-risk flag - docs(passkey): add login-history + first-passkey-risk design + bundle GeoLite2 - passkey: soft-disable credentials on delete + load exclusions from DB - swagger: fix /mcp empty-responses + enum-tag ActivityEvent fields - address Round 12 review findings on passkey-improve - address 8 review findings on passkey-improve - release agent_session request claim on post-claim error - fix two findings: premature approved status, swagger drift - fix three race + state-persistence findings from 2026-05-26 review - fix three verified bugs from review 2026-05-26 - add DisableAgentSessionApproveStepUp config flag - send email notifications on passkey lifecycle + recovery, with cancel link - backend fixes from passkey-improve review (H1-3, M1, M5, L2-3) - bind passkey.register.additional and passkey.remove to WebAuthn - bind wallet.send to a persisted WebAuthn step-up session - enable wallet.send and additional-passkey step-up by default - add GET /v1/security/stepup-log for the Security page audit panel - add recovery flow for lost-passkey + email-in-hand case - add POST /v1/passkey/delete with passkey.remove step-up - persist passkey cooldown state on the user and consult it in readiness - require step-up to add another passkey when one already exists - add wallet.send step-up token flow - bind agent_session.approve to action-bound step-up token - add GET /v1/passkey to list user's registered passkeys - add step-up activity kinds and recordStepUpEvent helper - add pkg/stepup for action-bound HMAC tokens - add passkey trust state and account readiness computation - add prod design doc for passkey-improvement - refine syntax - add thread-model for current email-otp + passkey design - refine Account States - add passkey-based security evolution plan --- # Release 2026-06-11 URL: https://docs.gokite.ai/changelog/2026/2026-06-11-release ## New features - **Security: step-up verification, passkey management, and account recovery.** Sensitive actions — sending funds, approving agent sessions, adding or removing passkeys — now require a quick passkey re-confirmation. Lost your passkey? You can now recover your account via email, with a one-click cancel link if it wasn't you. Passkey changes trigger email notifications, and your passkeys now show device names so you can tell them apart. - **Sign-in and security history.** Review recent sign-ins (time, location, device) and a log of all security verifications, so unfamiliar activity is easy to spot. - **Protocol-agnostic session negotiation.** Sessions can now be created and used regardless of which payment protocol a target service advertises. The session layer negotiates the protocol from the service response at runtime, so your agent code does not need to change when a service adds or changes payment protocols. This applies to both the CLI and the skills runtime. - **Per-endpoint pricing in search results.** The search tool now surfaces pricing details at the individual endpoint level. You can see the cost of each specific endpoint before making a request, rather than only seeing aggregate service-level pricing. - **Agent feedback.** Agents can now send feedback to us directly — reporting what worked, what didn't, and anything that got in their way — so we can spot rough edges and improve the platform faster. ## Improvements - **Correct user-agent headers on outbound requests.** Both the CLI (`kpass`) and the search tool (`ksearch`) now send a properly identified user-agent header on all outbound HTTP requests, fixing request attribution on services that key on the user-agent for rate-limiting or analytics. - **Quickstart paths and examples corrected.** The quickstart guide now reflects current installation paths and removes stale code examples that would fail on a fresh install. - **Skill loading optimized.** The skills runtime now applies load-time optimization, reducing overhead for agents that use multiple skills. ## Bug fixes - **Bundled `ksearch` binary is now locatable without repository access.** In environments where the private repository is not accessible — such as CI pipelines, fresh installs, or contributor setups — the skills package previously failed to locate its bundled `ksearch` binary. It is now found via a relative path that does not require repository credentials. --- # Release 2026-06-17 URL: https://docs.gokite.ai/changelog/2026/2026-06-17-release ## Improvements - **Quickstart paths and examples corrected.** The quickstart guide now reflects current installation paths and removes stale examples that would fail on a fresh setup. ## Bug fixes - **Windows installer no longer fails when resolving the latest version.** On Windows, installing or upgrading could fail with a type error while the installer determined the latest available version. Version resolution is now handled correctly, so installs and upgrades complete as expected. If a previous install failed at this step, re-run the installer to pick up the fix. --- # Release 2026-06-23 URL: https://docs.gokite.ai/changelog/2026/2026-06-23-release ## New features - **Cloud-project provisioning.** You can now provision and manage a dedicated cloud project end to end. Create a project, fund it from your Kite wallet with a passkey approval, retrieve deploy credentials and a ready-to-run deploy command, then pause, resume, or delete it as needed. Spend is metered against the project's prepaid credit, so costs stay bounded. The `kpass cloud project` command group drives the full lifecycle from the CLI. - **Sandbox test mode.** A new isolated test environment lets you exercise agent payment flows without touching live data or real funds. Switching into sandbox mode gives you a testnet wallet and a faucet for test tokens, with sessions, payments, and activity kept fully separate from your production account — so you can validate an integration before going live. - **Step-up browser approval for wallet sends.** When sending funds requires step-up verification, you can now complete the passkey approval in your browser. The approval page shows the transfer amount, asset, recipient, and sending wallet before you confirm, then reports the outcome with the transaction hash. This works from both the web app and the CLI — the CLI hands off a browser approval link and reports the result back. To get the CLI flow, upgrade to the latest `kpass` (Bundle 32) via `cli.gokite.ai`. - **Connect Passport to ChatGPT over MCP.** A hosted MCP endpoint with OAuth lets you add Kite Passport as a connector in ChatGPT and other MCP clients. Once connected and authorized, your agent can discover and pay for x402 services and create and list spending sessions directly from the chat client. > **Update 2026-09-01:** this hosted MCP endpoint and its ChatGPT connector were removed on 2026-09-01. Kite has no payment MCP; agents pay through the Passport skills and the kpass CLI. - **Solana settlement for x402 payments.** Agents can now pay merchants whose x402 services settle on Solana. Payment is collected from your Kite wallet as usual, and settlement to the merchant is handled automatically in USDC — extending paid-service reach beyond EVM with no change to how you authorize spend. ## Improvements - **13 new services reachable for x402 payments.** The x402 service catalog gained 13 newly allowlisted hosts, now live, so agents can pay them without requesting manual allowlisting. The additions span media generation (image and video, text-to-speech, memes), social and web data, file hosting, print-on-demand, travel data, IP geolocation, and crypto data. No action is needed — the new services are reachable now. --- # Release 2026-07-01 URL: https://docs.gokite.ai/changelog/2026/2026-07-01-release ## New features - **Redesigned dashboard.** The dashboard has been rebuilt around your spending sessions and now shows live data instead of static views. From one place you can review active sessions and their limits, see Transaction History for your account, and drill into a session's activity. Visiting `/dashboard` now sends you to the new `/overview`; the previous dashboard has been retired. - **Create and attach spending sessions from the browser.** A new create-session page lets you set up an attachable spending session directly in the dashboard. Sessions now surface whether they are attached or unattached, and their session id is one click to copy for use with an agent. - **Deploy a project to Google Cloud from a skill.** A new `cloud-deploy` skill provisions and deploys a local project to Google Cloud through `kpass cloud`, so an agent can take a project from your machine to a running cloud deployment end to end. To get the skill, upgrade to the latest `kpass`. ## Improvements - **Editable session budgets.** You can now edit a session's Max budget and Max-per-transaction limits directly in the dashboard instead of recreating the session. - **Activity categories and per-session filtering.** Account activity is now grouped into transaction, security, and lifecycle categories and can be filtered to a single session, making it easier to trace what an individual agent session did. - **Clearer merchant payment-decline details.** When a merchant declines an x402 payment, the response now carries the specific decline reason instead of an opaque error, so agents can react to and report why a payment did not go through. - **Test mode in the dashboard.** The sandbox test environment is now integrated into the dashboard, so you can switch into test mode and exercise payment flows with test funds without leaving the UI. ## Bug fixes - **Session spend now displays the correct dollar amount.** A session's spent total is now scaled by the settlement token's decimals, using the backend-provided display unit when available. Previously the amount could show raw token units rather than the actual dollar value. --- # Release 2026-07-08 URL: https://docs.gokite.ai/changelog/2026/2026-07-08-release ## New features - **Cross-chain payment routing.** x402 payments can now settle on a chain other than the one holding your funds — Passport automatically bridges and routes across Base, Tempo, and Solana, so you no longer have to move assets to the right chain before paying. - **Redesigned session dashboard with route timelines.** The dashboard has been rebuilt around your spending sessions and now shows a full timeline for routed payments — chain logos, bridged amounts, explorer links, and token logos for USDC and PYUSD — alongside session detail views. - **`kpass cloud` command group.** A new set of CLI commands drives the full cloud-project lifecycle — create, fund, provision, and deploy — directly from `kpass`. ## Improvements - **More reliable cross-chain routing.** Routing now considers the full set of bridge and swap candidates, treats a class of previously-fatal routing errors as transient and retryable, and applies a wider minimum cost-ratio cap for small cross-chain payments, so more small payments route successfully. - **Routing details in transaction history.** Transaction rows and account activity now show routing analytics and per-chain detail for routed payments. - **Per-chain activity in the CLI.** `kpass` activity logs now show which chain each transaction settled on, and CLI output detection is aligned with the server's responses. - **Skill docs updated for multichain.** The Passport skills bundle's docs and examples now reflect multichain payments and routing. ## Bug fixes - **Fixed cross-chain payments timing out on slow routes.** Payments routed through Solana or Tempo could occasionally fail with a gateway error when the cross-chain leg ran long. The write deadline has been restored so these payments now complete normally. - **Fixed incorrect activity rows for routed checkouts.** Activity entries for checkouts that used cross-chain routing now record correctly. - **Fixed dashboard overview clipping and sandbox balance display.** The overview page no longer clips content, and the sandbox environment now shows single-asset balances correctly. - **Restored sub-cent balance precision.** Balances that previously rounded away fractions of a cent now display full precision. - **Fixed CLI parsing when a colon command follows global flags.** `kpass` commands using the `resource:action` form now parse correctly when preceded by global flags. ## Important updates - **Passport now supports settlement on Base.** Direct-pay and cross-chain routing now handle settlement directly, replacing the treasury relay path. If your integration relied on the treasury relay or assumed Kite as the settlement chain, update it to expect Base settlement. - **Agent wallet USDC balances now show on Base.** As part of enabling Base support, USDC held by mainnet agent wallets was bridged 1:1 to each wallet's corresponding Base address. Check balances on your Base address going forward. - **Upgrade required for the CLI and skills bundle.** This release requires kpass 1.6.0 and skills bundle 35 or later. Upgrade with `curl -fsSL https://cli.gokite.ai/install.sh | bash`. --- # Release 2026-07-15 URL: https://docs.gokite.ai/changelog/2026/2026-07-15-release ## New features - **Deposit via Halliday.** A new onramp flow lets you deposit funds through Halliday. Deposits now appear in the account activity feed. - **Multi-offer merchant payments now complete end-to-end.** Passport parses 402 responses offering multiple payment options (e.g. Anthropic) and negotiates payment using the newer session protocol these merchants require. - **Binary merchant responses are now supported.** Raw binary media (audio, image, video) is returned as base64, and the CLI's `--output-file` flag saves it directly to disk. - **Vendor information on catalog pages.** API catalog pages now show vendor details for each listed service. - **Updated skill guidance for catalog-first, multichain workflows.** - **Agent session IDs are now abbreviated** (prefix…suffix) throughout the dashboard. ## Bug fixes - **Fixed paid requests stalling on wallet-identity challenges.** Merchants requiring a sign-in wallet-identity challenge before execution no longer stall the request — async jobs like video generation can poll for results without a second charge. - **Fixed deposits not appearing in balance immediately.** The balance cache now invalidates as soon as a settlement webhook confirms a deposit, fixing a display race. - **Fixed partner embed token delivery.** Embed tokens now pass via URL fragment and resolve with an `X-Embed-Token` header instead of a query parameter; reload behavior for embedded flows is documented. - **Fixed the session approval screen showing the requested TTL instead of the approved one.** - **Fixed error messages dropping the merchant's response body** on failed Tempo executions. - **Fixed per-transaction routing cap enforcement** to account for merchant and overhead costs. - **Fixed a scope-prefix matching bug** that could incorrectly match subtree scopes. - **Routed payment executes now return a normalized `payment_requirement`.** ## Important updates - **Upgrade the CLI.** This release requires Bundle 40 (kpass 1.9.0, ksearch 1.0.6, skills 1.6.3): `curl -fsSL https://cli.gokite.ai/install.sh | bash` --- # Release 2026-07-22 URL: https://docs.gokite.ai/changelog/2026/2026-07-22-release ## New features - **Robinhood Chain support, end-to-end.** Hold and send USDG on Robinhood Chain (chain ID 4663), with gas-sponsored sends/receives and automatic USDC→USDG routing. - **Guided first-run onboarding** for new dashboard users: welcome → install → guided tour. - **Active/History session tabs** in the dashboard. - **Richer catalog listings.** `service_endpoint` entries now include `example_request`, `probe_status`, and `pitfalls` fields. ## Improvements - **More precise headline balance**, now shown to two decimal places. - **Unattached-session guidance** in the dashboard for sessions not yet attached to an agent. - **Failed-route errors now include the merchant's response body** for easier debugging. - **Catalog data quality fixes**: merchant-info and facet fixes; fal.ai listings now correctly flagged image-only, with video-generation warnings. - **Passport Skills is now open source**, published from the public [gokite-ai/passport-skills](https://github.com/gokite-ai/passport-skills) repo, with new Robinhood wallet-ops docs. ## Bug fixes - **Fixed the Halliday deposit widget** — an unsupported wallet-type value was blocking deposits. - **Fixed a settlement-timing gap in agent-session payments** [security] that could allow repricing between detection and settlement; payments now settle in a single round trip. ## Important updates - **Passkey registration now requires a resident (discoverable) credential.** Existing passkeys may need re-registration; enrollment guidance to follow. - **Upgrade the CLI and skills bundle** to Bundle 42 (cli 1.9.2, ksearch 1.0.7, skills 1.7.1): `curl -fsSL https://cli.gokite.ai/install.sh | bash` --- # Release 2026-07-29 URL: https://docs.gokite.ai/changelog/2026/2026-07-29-release ## New features - **Clearer guidance on supported Receive assets.** Wallet Receive now shows which assets are supported for each network, making it easier to avoid sending unsupported deposits. - **Warnings against sending native gas tokens.** Receive flows now warn when a native gas token isn't supported for deposit, helping prevent lost transfers. - **Wallet-receive guidance extended to agent workflows.** Passport Skills now surface the same Receive guidance so agents get the same warnings as the dashboard. ## Improvements - **Backend dependency updates** improve reliability, security, and compatibility. - **More consistent wallet instructions** between the Passport web dashboard and the agent-facing Passport Skills guidance. ## Bug fixes - **Clarified the gas-sponsored Receive experience**, making it easier to confidently pick the correct asset and network for gas-sponsored deposits. ## Important updates - **Upgrade the CLI and skills bundle** to Bundle 43 (kpass 1.9.2, ksearch 1.0.7, skills 1.7.2): `curl -fsSL https://cli.gokite.ai/install.sh | bash` --- # Release 2026-10-09 URL: https://docs.gokite.ai/changelog/2026/2026-10-09-release ## New - The Passport dashboard and landing page have a new look, with Dark and Night modes. - Your Passport wallet supports Arc mainnet, and Arc mainnet services show up in the catalog. - You can browse Services and Recipes on the Explore page without logging in. - Passport can repay your Aave USDC loan on Base for you: set a health factor and an amount, approve once with your passkey, and it pays back that amount if your loan crosses that level. Your agent can arm, check, or cancel it with `kpass defi`. Requires Kite Passport CLI 6.8.0 or later. ## Improved - The Playground replays a real agent paying for a service under a session. - Session amounts show two decimals, and very small amounts show as "\<$0.01". - When you approve a session, you can type the expiry and switch between minutes, hours and days without changing its length. - A failed payment says "You were not charged" when nothing was charged, and shows the real amount otherwise. - If a voucher code can't be redeemed, you see why, and your balance updates right after you redeem one. - On phones, a routed payment's steps wrap to fit the screen. - The landing page has a back-to-top button, and Explore links open the Explore page. ## Fixed - The notification bell lists only requests still waiting for you. - Short or very cheap session requests are no longer refused. - x402 payments pick the matching payment method and skip options that can't settle. - The catalog no longer lists services on chains that stopped working. --- # Release 2026-10-13 URL: https://docs.gokite.ai/changelog/2026/2026-10-13-release ## October 13, 2026 *Dashboard v1.23.4 · Kite Passport CLI 6.8.2 · Skills 3.5.5* ### New - Tell Grok Bot or Muse "Set up Kite Passport from github.com/gokite-ai/passport-skills" and it sets up `kpass` with its `passport-setup` skill. - The install guide covers local coding agents and agents on a hosted computer (Grok Bot, Muse): [docs.gokite.ai/passport/install](https://docs.gokite.ai/passport/install) ### Improved - Your agent can pay from the account allowance you already approved, sharing it with your other agents instead of creating a new budget. - Approval pages show the agent's product name, such as "Claude Code" or "Cursor", instead of its raw type. - When the service catalog can't be reached, the kite-discovery skill tells your agent to check `KSEARCH_SERVICE_BASE_URL` first. ### Fixed - A fresh install now connects to the right Passport server instead of the dev server. Requires Kite Passport CLI 6.8.2 or later. - The installer and `kpass skills setup` add only the Passport skills for people, not the agent-to-agent skills. --- # Skills 3.5.7 URL: https://docs.gokite.ai/changelog/2026/2026-10-13-skills-v3-5-7 ## October 13, 2026 *Kite Passport CLI 6.8.2 · Skills 3.5.7* ### Improved - The `passport-setup` skill installs `kpass` with the setup script that ships with the skills, and the Getting Started guide uses the same `bash passport-skills/scripts/setup.sh` command. - Before using a Passport skill, the Kite Router skill checks that `kpass` is installed and runs `passport-setup` first if it isn't. - The installer download only runs over HTTPS and refuses redirects. --- # Release 2026-10-15 URL: https://docs.gokite.ai/changelog/2026/2026-10-15-release ## October 15, 2026 *Kite Passport docs* ### New - The home page Start here cards lead to "My agent pays for things", "I sell to agents" (x402 or MPP) and "I build on Kite Chain". - The About Kite page links the mission, architecture, core concepts, use cases, tokenomics and whitepaper pages as cards: [docs.gokite.ai/about](https://docs.gokite.ai/about) - Build with an LLM in Reference points AI agents to the Kite docs in llms.txt and llms-full.txt: [docs.gokite.ai/reference/build-with-an-llm](https://docs.gokite.ai/reference/build-with-an-llm) ### Improved - The Kite Passport section lists Install the CLI and agent skills, Payments, Funding Your Wallet and Service Provider Guide at one level, and Kite Passport and Reference open their own section pages. - The Payments page walks your agent through paying for a service: search the catalog with `ksearch`, create a spending session with `kpass`, and check the payment in your activity. - Funding Your Wallet matches the current Passport dashboard and shows adding USDC.e by card, direct deposit or Kite Bridge. - The Service Provider Guide covers accepting agent payments with x402 (with Pieverse) and MPP on one page. - The Passport Skills reference lists only the skills in the current bundle. - Error Codes says your agent shows you the new session settings and waits for your confirmation before creating a new session. - Old Passport and Guides links open a current page instead of a missing one. --- # Release 2026-10-30 URL: https://docs.gokite.ai/changelog/2026/2026-10-30-release ## October 30, 2026 *Dashboard v1.25.15* ### New - Home introduces Allowance with a one-time popover on the Allowance row when you haven't set one up, with "Set up allowance", "Not now" and "Learn more" options. - The Allowance setup form explains in one line what an allowance is and how it differs from a session. ### Fixed - Logging in from Safari on iPhone no longer stops at "Something went wrong: importing a module script failed"; the page now re-downloads the file that failed and reloads. --- # Release 2026-11-10 URL: https://docs.gokite.ai/changelog/2026/2026-11-10-release ## November 10, 2026 *Backend v4.0.13 · Dashboard v1.25.21 · Kite Passport CLI 6.13.2 · Skills 3.6.8* ### New - When a merchant fails after your agent pays, the agent is told right away that the merchant failed, no result was delivered, how much is held, and by when the final result is known. - Activity shows the same facts for that payment ("Merchant failed · held · result by a set time"), then updates to "Not charged · released" or "Charged" with the transaction hash once the result is confirmed. - Your agent receives the confirmed result without calling again with the same key; use `kpass session updates --wait` to wait for payment updates. Requires Kite Passport CLI 6.13.2 or later. - Skills now tell agents to wait for the confirmed result instead of retrying the same key. ### Improved - The original Kite Agent Passport wordmark is back on the landing page header and mobile menu. - The original wordmark is also back in the sidebar, the mobile header, and the light login and approve pages after you sign in. ### Fixed - Solana USDC sends to a new recipient now complete, because automatic gas sponsorship also covers creating the recipient's token account. - Signing up with an email address containing non-ASCII characters now returns a clear error ("email address must use plain ASCII characters") instead of a server error. - The account menu no longer lists your signed-in email a second time as an "expired" account. --- # Release 2026-11-13 URL: https://docs.gokite.ai/changelog/2026/2026-11-13-release ## November 13, 2026 *Backend v4.0.16 · Dashboard v1.25.24 · Kite Passport CLI 6.13.5 · Skills 3.6.11* ### New - You can sign in or sign up with Continue with Google; if the Google email already belongs to a Passport account, you confirm with a code sent to that email before the accounts are linked. - `kpass login` signs you in through your browser, and signing in once works for the CLI in every repo on your machine. - Dashboard pages that `kpass` opens now arrive already signed in, with no extra email or code. - A new key that spends your allowance waits for you to approve it with your passkey on a dedicated approval page. ### Improved - New and returning users sign in with the same single email code, right on the page you were visiting, without a detour through other tabs. - The dashboard keeps you signed in for 30 days instead of signing you out after 24 hours. - Your agent's sign-in guidance in Skills now uses the browser sign-in. ### Fixed - Signing up with a new email from two places at once no longer fails with a server error. - Passkey registration no longer fails when your device sends back a response that can't be read, and shows a clear message instead. - Setting up your first passkey no longer shows a generic error in your other signed-in sessions. - Approve and reject options no longer require a passkey page for agent sessions that don't need one. --- # API reference URL: https://docs.gokite.ai/api-reference Agents and apps use Kite Passport through the kpass CLI and the Passport skills, and there is no public HTTP API reference yet. - [kpass CLI](/reference/kpass-cli) - [Passport skills](/reference/passport-skills) - [Error codes](/reference/error-codes) - [Install Passport](/passport/install) This page will hold the HTTP reference once a public spec is published. --- # Blog URL: https://docs.gokite.ai/blog Coming soon.