@exagent/sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,2458 @@
+import * as viem from 'viem';
+import { Address, Hash, Chain, Account, WalletClient } from 'viem';
+import * as viem_chains from 'viem/chains';
+
+/**
+ * Agent profile as stored on-chain
+ */
+interface AgentProfile {
+    agentId: bigint;
+    owner: Address;
+    name: string;
+    metadataURI: string;
+    registrationTime: bigint;
+    verified: boolean;
+    linkedWalletCount: bigint;
+}
+/**
+ * Agent metadata stored on IPFS
+ */
+interface AgentMetadata {
+    name: string;
+    description: string;
+    capabilities: string[];
+    model?: string;
+    framework?: string;
+    avatar?: string;
+    website?: string;
+    social?: {
+        twitter?: string;
+        moltbook?: string;
+    };
+}
+/**
+ * Trade intent for broadcasting
+ */
+interface TradeIntent {
+    action: 'BUY' | 'SELL';
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    minAmountOut?: bigint;
+    maxSlippageBps?: number;
+    deadline?: number;
+}
+/**
+ * M2M service request
+ */
+interface ServiceRequest {
+    serviceType: string;
+    providerId?: bigint;
+    maxPriceAX: bigint;
+    payload: Record<string, unknown>;
+    deadline?: number;
+}
+/**
+ * Performance metrics snapshot
+ */
+interface PerformanceSnapshot {
+    agentId: bigint;
+    timestamp: bigint;
+    pnlBps: number;
+    tradeCount: number;
+    volumeUSD: bigint;
+    sharpeRatio?: number;
+    sortinoRatio?: number;
+    maxDrawdownBps?: number;
+}
+/**
+ * DEX route quote from 0x API
+ */
+interface RouteQuote {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    amountOut: string;
+    minAmountOut: string;
+    priceImpactBps: number;
+    route: RouteStep[];
+    transaction: {
+        to: Address;
+        data: `0x${string}`;
+        value: string;
+    };
+    gasEstimate: string;
+    validUntil: number;
+    permit2?: {
+        eip712: unknown;
+    };
+    issues?: {
+        allowance?: {
+            spender: Address;
+            actual: string;
+            expected: string;
+        };
+    };
+    mock?: boolean;
+}
+/**
+ * Route step through a DEX
+ */
+interface RouteStep {
+    dex: string;
+    pool: string;
+    share: number;
+}
+/**
+ * Price quote (no transaction data)
+ */
+interface PriceQuote {
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    amountOut: string;
+    priceImpactBps: number;
+    mock?: boolean;
+}
+/**
+ * Router trade response - transaction routed through ExagentRouter
+ */
+interface RouterTradeResponse {
+    agentId: number;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    amountOut: string;
+    minAmountOut: string;
+    priceImpactBps: number;
+    route: RouteStep[];
+    transaction: {
+        to: Address;
+        data: `0x${string}`;
+        value: string;
+    };
+    approvals: Array<{
+        token: Address;
+        spender: Address;
+        amount: string;
+    }>;
+    gasEstimate: string;
+    validUntil: number;
+    attribution: {
+        router: Address;
+        aggregator: Address;
+        agentId: number;
+    };
+    mock?: boolean;
+}
+/**
+ * Trade execution result
+ */
+interface TradeResult {
+    hash: Hash;
+    agentId: bigint;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: string;
+    expectedAmountOut: string;
+}
+/**
+ * Basic staking info (raw contract data)
+ */
+interface StakeInfo {
+    amount: bigint;
+    unlockTime: bigint;
+    lockDuration: bigint;
+    vEXABalance: bigint;
+}
+/**
+ * Extended staking info with computed fields
+ */
+interface StakingInfo$1 extends StakeInfo {
+    /** Current vEXA balance (with time decay applied) */
+    currentVeEXA: bigint;
+    /** Whether the lock has expired */
+    isUnlocked: boolean;
+    /** Remaining time until unlock in seconds */
+    remainingLockTime: bigint;
+}
+/**
+ * Delegation info for an agent
+ */
+interface DelegationInfo$1 {
+    /** Total vEXA delegated to this agent */
+    totalVeEXA: bigint;
+    /** Number of unique delegators */
+    delegatorCount: bigint;
+}
+/**
+ * Discount tier for trading fee reductions based on vEXA holdings
+ * - none: 0% discount (0 vEXA)
+ * - bronze: 10% discount (10,000+ vEXA)
+ * - silver: 25% discount (50,000+ vEXA)
+ * - gold: 50% discount (100,000+ vEXA)
+ */
+type DiscountTier$1 = 'none' | 'bronze' | 'silver' | 'gold';
+/**
+ * Vault configuration for creating a new vault
+ */
+interface VaultConfig {
+    agentId: bigint;
+    asset: Address;
+    name: string;
+    symbol: string;
+    feeRecipient: Address;
+    performanceFeeBps?: number;
+    managementFeeBps?: number;
+}
+/**
+ * Vault summary for listing
+ */
+interface VaultSummary {
+    address: Address;
+    name: string;
+    symbol: string;
+    asset: Address;
+    agentId: bigint;
+    totalAssets: bigint;
+    sharePrice: bigint;
+    performanceFeeBps: number;
+    managementFeeBps: number;
+    depositorCount: number;
+    totalPnlBps: number;
+    isAcceptingDeposits: boolean;
+}
+/**
+ * User's vault position for portfolio display
+ */
+interface UserVaultPosition {
+    vault: Address;
+    vaultName: string;
+    shares: bigint;
+    assetsValue: bigint;
+    entryPrice: bigint;
+    currentPrice: bigint;
+    pnlBps: number;
+    pnlUsd: bigint;
+    pendingWithdrawals: bigint;
+}
+/**
+ * Vault deposit/withdrawal history entry
+ */
+interface VaultActivityEntry {
+    type: 'deposit' | 'withdraw' | 'request_withdrawal' | 'claim_withdrawal' | 'emergency_withdraw';
+    user: Address;
+    vault: Address;
+    shares: bigint;
+    assets: bigint;
+    timestamp: bigint;
+    txHash: Hash;
+}
+/**
+ * Vault trade executed by agent
+ */
+interface VaultTradeEntry {
+    agentId: bigint;
+    vault: Address;
+    tokenIn: Address;
+    tokenOut: Address;
+    amountIn: bigint;
+    amountOut: bigint;
+    aggregator: Address;
+    timestamp: bigint;
+    txHash: Hash;
+}
+
+/**
+ * Wrapper for ExagentRegistry contract interactions
+ */
+declare class ExagentRegistry {
+    private readonly address;
+    private readonly publicClient;
+    private readonly walletClient?;
+    private readonly chain;
+    private readonly account?;
+    constructor(address: Address, publicClient: any, walletClient: any | undefined, chain: Chain, account?: Account);
+    /**
+     * Register a new agent
+     * @param name Unique agent name (3-32 chars, alphanumeric + spaces/hyphens/underscores)
+     * @param metadataURI IPFS URI for agent metadata
+     * @returns Transaction hash
+     */
+    register(name: string, metadataURI: string): Promise<Hash>;
+    /**
+     * Check if a name is available for registration
+     * @param name The name to check
+     * @returns True if the name can be used
+     */
+    isNameAvailable(name: string): Promise<boolean>;
+    /**
+     * Get the agent ID that owns a specific name
+     * @param name The name to look up
+     * @returns Agent ID (0 if not taken)
+     */
+    getAgentByName(name: string): Promise<bigint>;
+    /**
+     * Link the wallet used by the agent to their agent ID
+     * @param agentId The agent's ID
+     * @returns Transaction hash
+     */
+    linkOwnWallet(agentId: bigint): Promise<Hash>;
+    /**
+     * Link an external wallet with signature proof
+     * @param agentId The agent's ID
+     * @param wallet The wallet to link
+     * @param signature Signature from the wallet proving ownership
+     * @returns Transaction hash
+     */
+    linkWallet(agentId: bigint, wallet: Address, signature: `0x${string}`): Promise<Hash>;
+    /**
+     * Unlink a wallet from an agent
+     * @param agentId The agent's ID
+     * @param wallet The wallet to unlink
+     * @returns Transaction hash
+     */
+    unlinkWallet(agentId: bigint, wallet: Address): Promise<Hash>;
+    /**
+     * Update agent metadata
+     * @param agentId The agent's ID
+     * @param newURI New IPFS URI for metadata
+     * @returns Transaction hash
+     */
+    updateMetadata(agentId: bigint, newURI: string): Promise<Hash>;
+    /**
+     * Get agent profile by ID
+     * @param agentId The agent's ID
+     * @returns Agent profile data
+     */
+    getAgent(agentId: bigint): Promise<AgentProfile>;
+    /**
+     * Get all linked wallets for an agent
+     * @param agentId The agent's ID
+     * @returns Array of linked wallet addresses
+     */
+    getLinkedWallets(agentId: bigint): Promise<Address[]>;
+    /**
+     * Get agent ID for a wallet (for trade attribution)
+     * @param wallet The wallet address
+     * @returns Agent ID (0 if not linked)
+     */
+    getAgentForWallet(wallet: Address): Promise<bigint>;
+    /**
+     * Check if a wallet is linked to a specific agent
+     * @param agentId The agent's ID
+     * @param wallet The wallet address to check
+     * @returns True if the wallet is linked to the agent
+     */
+    isLinkedWallet(agentId: bigint, wallet: Address): Promise<boolean>;
+    /**
+     * Get the nonce for wallet linking signature
+     * @param wallet The wallet address
+     * @returns Current nonce
+     */
+    getNonce(wallet: Address): Promise<bigint>;
+    /**
+     * Get the next agent ID that will be assigned
+     * @returns Next agent ID
+     */
+    getNextAgentId(): Promise<bigint>;
+    /**
+     * Generate the message to sign for wallet linking
+     * @param wallet The wallet to link
+     * @param agentId The agent ID to link to
+     * @param nonce The current nonce for the wallet
+     * @returns Message to sign
+     */
+    static generateLinkMessage(wallet: Address, agentId: bigint, nonce: bigint): string;
+    /**
+     * Get the agent owned by a wallet (not linked, owned)
+     * @param wallet The wallet to look up
+     * @returns Agent ID (0 if wallet doesn't own an agent)
+     */
+    getAgentByOwner(wallet: Address): Promise<bigint>;
+    /**
+     * Check if a wallet can register a new agent
+     * @param wallet The wallet to check
+     * @returns Object with canRegister boolean and existingAgentId (0 if none)
+     */
+    canWalletRegister(wallet: Address): Promise<{
+        canRegister: boolean;
+        existingAgentId: bigint;
+    }>;
+    /**
+     * Get the registry contract version
+     * @returns Version string (e.g., "4.0.0")
+     */
+    getVersion(): Promise<string>;
+    /**
+     * Update the agent's LLM config hash on-chain
+     * @param agentId The agent's ID
+     * @param configHash The keccak256 hash of (provider, model)
+     * @returns Transaction hash
+     */
+    updateConfig(agentId: bigint, configHash: `0x${string}`): Promise<Hash>;
+    /**
+     * Get the current config hash for an agent
+     * @param agentId The agent's ID
+     * @returns Config hash (bytes32(0) if never set)
+     */
+    getConfigHash(agentId: bigint): Promise<`0x${string}`>;
+    /**
+     * Get the current epoch ID for an agent
+     * @param agentId The agent's ID
+     * @returns Current epoch (0 if never configured)
+     */
+    getCurrentEpoch(agentId: bigint): Promise<bigint>;
+    /**
+     * Get full config info for an agent
+     * @param agentId The agent's ID
+     * @returns AgentConfig struct (configHash, epochId, epochStartBlock)
+     */
+    getAgentConfig(agentId: bigint): Promise<{
+        configHash: `0x${string}`;
+        epochId: bigint;
+        epochStartBlock: bigint;
+    }>;
+    /**
+     * Get the config hash for a specific epoch
+     * @param agentId The agent's ID
+     * @param epochId The epoch to look up
+     * @returns Config hash for that epoch
+     */
+    getEpochConfigHash(agentId: bigint, epochId: bigint): Promise<`0x${string}`>;
+    /**
+     * Calculate the config hash for a provider and model
+     * @param provider The LLM provider name (e.g., "openai", "anthropic")
+     * @param model The model name (e.g., "gpt-4", "claude-opus-4.5")
+     * @returns keccak256 hash of the config
+     */
+    static calculateConfigHash(provider: string, model: string): `0x${string}`;
+}
+
+/**
+ * Vault info
+ */
+interface VaultInfo {
+    address: Address;
+    name: string;
+    symbol: string;
+    asset: Address;
+    agentId: bigint;
+    totalAssets: bigint;
+    totalSupply: bigint;
+    sharePrice: bigint;
+    highWaterMark: bigint;
+    performanceFeeBps: bigint;
+    managementFeeBps: bigint;
+    feeRecipient: Address;
+    depositsPaused: boolean;
+    withdrawalsPaused: boolean;
+    circuitBreakerActive: boolean;
+}
+/**
+ * User's vault position
+ */
+interface VaultPosition {
+    shares: bigint;
+    effectiveShares: bigint;
+    pendingWithdrawals: bigint;
+    assetsValue: bigint;
+    userHighWaterMark: bigint;
+    canWithdraw: boolean;
+    cooldownRemaining: bigint;
+}
+/**
+ * Withdrawal request details
+ */
+interface WithdrawalRequest {
+    requestId: bigint;
+    owner: Address;
+    receiver: Address;
+    shares: bigint;
+    requestTime: bigint;
+    processed: boolean;
+    claimableAt: bigint;
+}
+/**
+ * ExagentVault SDK interface for ERC-4626 copy trading vaults
+ */
+declare class ExagentVault {
+    readonly address: Address;
+    private readonly publicClient;
+    private readonly walletClient?;
+    private readonly chain;
+    private readonly account?;
+    constructor(vaultAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
+    /**
+     * Get comprehensive vault info
+     */
+    getVaultInfo(): Promise<VaultInfo>;
+    /**
+     * Get user's position in the vault
+     */
+    getPosition(user: Address): Promise<VaultPosition>;
+    /**
+     * Get current share price (assets per share, scaled to 1e18)
+     */
+    getSharePrice(): Promise<bigint>;
+    /**
+     * Preview deposit - get shares for given assets
+     */
+    previewDeposit(assets: bigint): Promise<bigint>;
+    /**
+     * Preview withdrawal - get assets for given shares
+     */
+    previewRedeem(shares: bigint): Promise<bigint>;
+    /**
+     * Get max deposit amount
+     */
+    maxDeposit(receiver: Address): Promise<bigint>;
+    /**
+     * Get max withdrawal amount
+     */
+    maxWithdraw(owner: Address): Promise<bigint>;
+    /**
+     * Get rate limit status
+     */
+    getRateLimitStatus(): Promise<{
+        remaining: bigint;
+        periodEnds: bigint;
+    }>;
+    /**
+     * Get pending withdrawal request
+     */
+    getPendingWithdrawal(requestId: bigint): Promise<WithdrawalRequest>;
+    /**
+     * Deposit assets into the vault
+     * @param assets Amount of underlying asset to deposit
+     * @param receiver Address to receive vault shares
+     * @returns Transaction hash
+     */
+    deposit(assets: bigint, receiver?: Address): Promise<Hash>;
+    /**
+     * Withdraw assets from the vault
+     * @param assets Amount of underlying asset to withdraw
+     * @param receiver Address to receive assets
+     * @param owner Address whose shares to burn (defaults to caller)
+     * @returns Transaction hash
+     */
+    withdraw(assets: bigint, receiver?: Address, owner?: Address): Promise<Hash>;
+    /**
+     * Redeem shares for assets
+     * @param shares Amount of shares to redeem
+     * @param receiver Address to receive assets
+     * @param owner Address whose shares to burn (defaults to caller)
+     * @returns Transaction hash
+     */
+    redeem(shares: bigint, receiver?: Address, owner?: Address): Promise<Hash>;
+    /**
+     * Request a queued withdrawal (for large amounts)
+     * @param shares Amount of shares to withdraw
+     * @param receiver Address to receive assets
+     * @returns Transaction hash
+     */
+    requestWithdrawal(shares: bigint, receiver?: Address): Promise<Hash>;
+    /**
+     * Claim a pending withdrawal request
+     * @param requestId The withdrawal request ID
+     * @returns Transaction hash
+     */
+    claimWithdrawal(requestId: bigint): Promise<Hash>;
+    /**
+     * Cancel a pending withdrawal request
+     * @param requestId The withdrawal request ID
+     * @returns Transaction hash
+     */
+    cancelWithdrawal(requestId: bigint): Promise<Hash>;
+    /**
+     * Emergency withdrawal (bypasses cooldown, forfeits pending rewards)
+     * @returns Transaction hash
+     */
+    emergencyWithdraw(): Promise<Hash>;
+    /**
+     * Approve vault to spend underlying asset
+     * @param assetAddress The asset token address
+     * @param amount Amount to approve
+     * @returns Transaction hash
+     */
+    approveAsset(assetAddress: Address, amount: bigint): Promise<Hash>;
+}
+
+/**
+ * ExagentStaking ABI
+ */
+declare const EXAGENT_STAKING_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "exaToken";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalStaked";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalVeEXA";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "registry";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MIN_LOCK_DURATION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MAX_LOCK_DURATION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "PRECISION";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "stake";
+    readonly inputs: readonly [{
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "lockDuration";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "unstake";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "extendLock";
+    readonly inputs: readonly [{
+        readonly name: "newLockDuration";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "claimRewards";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "claimRewardsMulti";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "claimRewardsToken";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "delegate";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "undelegate";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "redelegate";
+    readonly inputs: readonly [{
+        readonly name: "newAgentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "stakes";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "unlockTime";
+        readonly type: "uint256";
+    }, {
+        readonly name: "lockDuration";
+        readonly type: "uint256";
+    }, {
+        readonly name: "vEXABalance";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getVeEXABalance";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "calculateVeEXA";
+    readonly inputs: readonly [{
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "lockDuration";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "pure";
+}, {
+    readonly type: "function";
+    readonly name: "pendingRewards";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "pendingRewardsForToken";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getDelegatedAgent";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getAgentDelegation";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "vexa";
+        readonly type: "uint256";
+    }, {
+        readonly name: "count";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getDiscountTier";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "discountBps";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getRewardTokens";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address[]";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "delegatedTo";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "userDelegatedVeEXA";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "agentDelegatedVeEXA";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "agentDelegatorCount";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "isRewardToken";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "event";
+    readonly name: "Staked";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "lockDuration";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "unlockTime";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "vEXABalance";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Unstaked";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "LockExtended";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "newUnlockTime";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }, {
+        readonly name: "newVeEXABalance";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "RewardsClaimed";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Delegated";
+    readonly inputs: readonly [{
+        readonly name: "delegator";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "veEXAAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "Undelegated";
+    readonly inputs: readonly [{
+        readonly name: "delegator";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "veEXAAmount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "MultiTokenRewardsClaimed";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "token";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "amount";
+        readonly type: "uint256";
+        readonly indexed: false;
+    }];
+}];
+/**
+ * Staking info for a user
+ */
+interface StakingInfo {
+    /** Amount of EXA staked */
+    amount: bigint;
+    /** Timestamp when stake can be withdrawn */
+    unlockTime: bigint;
+    /** Original lock duration in seconds */
+    lockDuration: bigint;
+    /** vEXA balance at stake time (before time decay) */
+    vEXABalance: bigint;
+    /** Current vEXA balance (with time decay applied) */
+    currentVeEXA: bigint;
+    /** Whether the lock has expired */
+    isUnlocked: boolean;
+    /** Remaining time until unlock in seconds */
+    remainingLockTime: bigint;
+}
+/**
+ * Delegation info for an agent
+ */
+interface DelegationInfo {
+    /** Total vEXA delegated to this agent */
+    totalVeEXA: bigint;
+    /** Number of unique delegators */
+    delegatorCount: bigint;
+}
+/**
+ * Discount tier for trading fee reductions
+ */
+type DiscountTier = 'none' | 'bronze' | 'silver' | 'gold';
+/**
+ * Discount tier thresholds in basis points
+ */
+declare const DISCOUNT_TIERS: {
+    readonly none: 0;
+    readonly bronze: 1000;
+    readonly silver: 2500;
+    readonly gold: 5000;
+};
+/**
+ * ExagentStaking SDK interface for vEXA staking, rewards, and delegation
+ */
+declare class ExagentStaking {
+    readonly address: Address;
+    private readonly publicClient;
+    private readonly walletClient?;
+    private readonly chain;
+    private readonly account?;
+    constructor(stakingAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
+    /**
+     * Stake EXA tokens to receive vEXA voting power
+     * @param amount Amount of EXA to stake (in wei)
+     * @param lockDuration Lock duration in seconds (30 days to 2 years)
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Stake 1000 EXA for 6 months
+     * const tx = await staking.stake(
+     *   parseEther('1000'),
+     *   BigInt(180 * 24 * 60 * 60) // 180 days in seconds
+     * );
+     * ```
+     */
+    stake(amount: bigint, lockDuration: bigint): Promise<Hash>;
+    /**
+     * Unstake EXA tokens after lock expires
+     * @returns Transaction hash
+     * @throws Error if lock has not expired
+     */
+    unstake(): Promise<Hash>;
+    /**
+     * Extend lock duration for additional voting power
+     * @param newLockDuration New lock duration in seconds (must be longer than remaining)
+     * @returns Transaction hash
+     */
+    extendLock(newLockDuration: bigint): Promise<Hash>;
+    /**
+     * Claim accumulated EXA rewards
+     * @returns Transaction hash
+     */
+    claimRewards(): Promise<Hash>;
+    /**
+     * Claim all pending multi-token rewards (ETH, USDC, etc.)
+     * @returns Transaction hash
+     */
+    claimRewardsMulti(): Promise<Hash>;
+    /**
+     * Claim pending rewards for a specific token
+     * @param token The reward token address to claim
+     * @returns Transaction hash
+     */
+    claimRewardsToken(token: Address): Promise<Hash>;
+    /**
+     * Delegate vEXA voting power to an agent ("Agent Wars")
+     * @param agentId The agent ID to delegate to
+     * @returns Transaction hash
+     */
+    delegate(agentId: bigint): Promise<Hash>;
+    /**
+     * Remove delegation from current agent
+     * @returns Transaction hash
+     */
+    undelegate(): Promise<Hash>;
+    /**
+     * Re-delegate to a different agent (undelegate + delegate in one tx)
+     * @param newAgentId The new agent ID to delegate to
+     * @returns Transaction hash
+     */
+    redelegate(newAgentId: bigint): Promise<Hash>;
+    /**
+     * Get comprehensive staking info for a user
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Staking info with amount, unlock time, and vEXA balance
+     */
+    getStakeInfo(userAddress?: Address): Promise<StakingInfo>;
+    /**
+     * Get current vEXA balance (with time decay applied)
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Current vEXA balance
+     */
+    getVeEXABalance(userAddress?: Address): Promise<bigint>;
+    /**
+     * Get the agent ID a user is delegating to
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Agent ID (0 if not delegating)
+     */
+    getDelegatedAgent(userAddress?: Address): Promise<bigint>;
+    /**
+     * Get delegation stats for an agent
+     * @param agentId The agent ID to check
+     * @returns Delegation info with total vEXA and delegator count
+     */
+    getAgentDelegation(agentId: bigint): Promise<DelegationInfo>;
+    /**
+     * Get trading fee discount tier for a user
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Discount tier name and basis points
+     */
+    getDiscountTier(userAddress?: Address): Promise<{
+        tier: DiscountTier;
+        discountBps: bigint;
+    }>;
+    /**
+     * Get pending EXA rewards for a user
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Pending reward amount in wei
+     */
+    pendingRewards(userAddress?: Address): Promise<bigint>;
+    /**
+     * Get pending rewards for a specific token
+     * @param token The reward token address
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Pending reward amount in wei
+     */
+    pendingRewardsMulti(token: Address, userAddress?: Address): Promise<bigint>;
+    /**
+     * Get list of whitelisted reward tokens
+     * @returns Array of reward token addresses
+     */
+    getRewardTokens(): Promise<Address[]>;
+    /**
+     * Check if a token is whitelisted for rewards
+     * @param token The token address to check
+     * @returns True if token is whitelisted
+     */
+    isRewardToken(token: Address): Promise<boolean>;
+    /**
+     * Get total staked EXA across all users
+     * @returns Total staked amount in wei
+     */
+    getTotalStaked(): Promise<bigint>;
+    /**
+     * Get total vEXA supply across all users
+     * @returns Total vEXA supply
+     */
+    getTotalVeEXA(): Promise<bigint>;
+    /**
+     * Calculate vEXA balance for a given stake (preview)
+     * @param amount Amount of EXA to stake
+     * @param lockDuration Lock duration in seconds
+     * @returns Expected vEXA balance
+     */
+    calculateVeEXA(amount: bigint, lockDuration: bigint): Promise<bigint>;
+    /**
+     * Get the EXA token address
+     * @returns EXA token contract address
+     */
+    getExaTokenAddress(): Promise<Address>;
+    /**
+     * Approve EXA token spending for staking
+     * @param amount Amount to approve
+     * @returns Transaction hash
+     */
+    approveExa(amount: bigint): Promise<Hash>;
+    /** Minimum lock duration: 30 days in seconds */
+    static readonly MIN_LOCK_DURATION: bigint;
+    /** Maximum lock duration: 2 years in seconds */
+    static readonly MAX_LOCK_DURATION: bigint;
+    /** 1 month lock duration in seconds */
+    static readonly LOCK_1_MONTH: bigint;
+    /** 3 months lock duration in seconds */
+    static readonly LOCK_3_MONTHS: bigint;
+    /** 6 months lock duration in seconds */
+    static readonly LOCK_6_MONTHS: bigint;
+    /** 1 year lock duration in seconds */
+    static readonly LOCK_1_YEAR: bigint;
+    /** 2 years lock duration in seconds */
+    static readonly LOCK_2_YEARS: bigint;
+}
+
+declare const CHAIN_CONFIG: {
+    readonly mainnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://basescan.org";
+                readonly apiUrl: "https://api.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 1: {
+                    readonly address: "0x43edB88C4B80fDD2AdFF2412A7BebF9dF42cB40e";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 1: {
+                    readonly address: "0x56315b90c40730925ec5485cf004d835058518A0";
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 5022;
+            };
+            readonly portal: {
+                readonly 1: {
+                    readonly address: "0x49048044D57e1C92A77f79988d21Fa8fAF74E97e";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 1: {
+                    readonly address: "0x3154Cf16ccdb4C6d922629664174b904d80F2C35";
+                    readonly blockCreated: 17482143;
+                };
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 8453;
+        name: "Base";
+        nativeCurrency: {
+            readonly name: "Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://mainnet.base.org"];
+            };
+        };
+        sourceId: 1;
+        testnet?: boolean | undefined | undefined;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: viem.Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: `0x${string}`;
+                    mixHash: viem.Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: viem.Hash;
+                    receiptsRoot: viem.Hex;
+                    sealFields: viem.Hex[];
+                    sha3Uncles: viem.Hash;
+                    size: bigint;
+                    stateRoot: viem.Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                    transactionsRoot: viem.Hash;
+                    uncles: viem.Hash[];
+                    withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: viem.Hex;
+                    type: "deposit";
+                } | {
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    v: bigint;
+                    to: `0x${string}` | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly viem.Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList: viem.SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: viem.Hash;
+                    blockNumber: bigint;
+                    contractAddress: `0x${string}` | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: `0x${string}`;
+                    gasUsed: bigint;
+                    logs: viem.Log<bigint, number, false>[];
+                    logsBloom: viem.Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: `0x${string}` | null;
+                    transactionHash: viem.Hash;
+                    transactionIndex: number;
+                    type: viem.TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers: {
+            readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+        };
+        verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+    };
+    readonly testnet: {
+        blockExplorers: {
+            readonly default: {
+                readonly name: "Basescan";
+                readonly url: "https://sepolia.basescan.org";
+                readonly apiUrl: "https://api-sepolia.basescan.org/api";
+            };
+        };
+        blockTime: 2000;
+        contracts: {
+            readonly disputeGameFactory: {
+                readonly 11155111: {
+                    readonly address: "0xd6E6dBf4F7EA0ac412fD8b65ED297e64BB7a06E1";
+                };
+            };
+            readonly l2OutputOracle: {
+                readonly 11155111: {
+                    readonly address: "0x84457ca9D0163FbC4bbfe4Dfbb20ba46e48DF254";
+                };
+            };
+            readonly portal: {
+                readonly 11155111: {
+                    readonly address: "0x49f53e41452c74589e85ca1677426ba426459e85";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly l1StandardBridge: {
+                readonly 11155111: {
+                    readonly address: "0xfd0Bf71F60660E2f608ed56e1659C450eB113120";
+                    readonly blockCreated: 4446677;
+                };
+            };
+            readonly multicall3: {
+                readonly address: "0xca11bde05977b3631167028862be2a173976ca11";
+                readonly blockCreated: 1059647;
+            };
+            readonly gasPriceOracle: {
+                readonly address: "0x420000000000000000000000000000000000000F";
+            };
+            readonly l1Block: {
+                readonly address: "0x4200000000000000000000000000000000000015";
+            };
+            readonly l2CrossDomainMessenger: {
+                readonly address: "0x4200000000000000000000000000000000000007";
+            };
+            readonly l2Erc721Bridge: {
+                readonly address: "0x4200000000000000000000000000000000000014";
+            };
+            readonly l2StandardBridge: {
+                readonly address: "0x4200000000000000000000000000000000000010";
+            };
+            readonly l2ToL1MessagePasser: {
+                readonly address: "0x4200000000000000000000000000000000000016";
+            };
+        };
+        ensTlds?: readonly string[] | undefined;
+        id: 84532;
+        name: "Base Sepolia";
+        nativeCurrency: {
+            readonly name: "Sepolia Ether";
+            readonly symbol: "ETH";
+            readonly decimals: 18;
+        };
+        experimental_preconfirmationTime?: number | undefined | undefined;
+        rpcUrls: {
+            readonly default: {
+                readonly http: readonly ["https://sepolia.base.org"];
+            };
+        };
+        sourceId: 11155111;
+        testnet: true;
+        custom?: Record<string, unknown> | undefined;
+        extendSchema?: Record<string, unknown> | undefined;
+        fees?: viem.ChainFees<undefined> | undefined;
+        formatters: {
+            readonly block: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                    baseFeePerGas: bigint | null;
+                    blobGasUsed: bigint;
+                    difficulty: bigint;
+                    excessBlobGas: bigint;
+                    extraData: viem.Hex;
+                    gasLimit: bigint;
+                    gasUsed: bigint;
+                    hash: `0x${string}` | null;
+                    logsBloom: `0x${string}` | null;
+                    miner: `0x${string}`;
+                    mixHash: viem.Hash;
+                    nonce: `0x${string}` | null;
+                    number: bigint | null;
+                    parentBeaconBlockRoot?: `0x${string}` | undefined;
+                    parentHash: viem.Hash;
+                    receiptsRoot: viem.Hex;
+                    sealFields: viem.Hex[];
+                    sha3Uncles: viem.Hash;
+                    size: bigint;
+                    stateRoot: viem.Hash;
+                    timestamp: bigint;
+                    totalDifficulty: bigint | null;
+                    transactions: `0x${string}`[] | viem_chains.OpStackTransaction<boolean>[];
+                    transactionsRoot: viem.Hash;
+                    uncles: viem.Hash[];
+                    withdrawals?: viem.Withdrawal[] | undefined | undefined;
+                    withdrawalsRoot?: `0x${string}` | undefined;
+                } & {};
+                type: "block";
+            };
+            readonly transaction: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransaction, action?: string | undefined) => ({
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: boolean;
+                    mint?: bigint | undefined | undefined;
+                    sourceHash: viem.Hex;
+                    type: "deposit";
+                } | {
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    v: bigint;
+                    to: `0x${string}` | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    nonce: number;
+                    value: bigint;
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    accessList?: undefined | undefined;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId?: number | undefined;
+                    yParity?: undefined | undefined;
+                    type: "legacy";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip2930";
+                    gasPrice: bigint;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas?: undefined | undefined;
+                    maxPriorityFeePerGas?: undefined | undefined;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip1559";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList?: undefined | undefined;
+                    blobVersionedHashes: readonly viem.Hex[];
+                    chainId: number;
+                    type: "eip4844";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas: bigint;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                } | {
+                    blockHash: `0x${string}` | null;
+                    blockNumber: bigint | null;
+                    from: `0x${string}`;
+                    gas: bigint;
+                    hash: viem.Hash;
+                    input: viem.Hex;
+                    nonce: number;
+                    r: viem.Hex;
+                    s: viem.Hex;
+                    to: `0x${string}` | null;
+                    transactionIndex: number | null;
+                    typeHex: viem.Hex | null;
+                    v: bigint;
+                    value: bigint;
+                    yParity: number;
+                    accessList: viem.AccessList;
+                    authorizationList: viem.SignedAuthorizationList;
+                    blobVersionedHashes?: undefined | undefined;
+                    chainId: number;
+                    type: "eip7702";
+                    gasPrice?: undefined | undefined;
+                    maxFeePerBlobGas?: undefined | undefined;
+                    maxFeePerGas: bigint;
+                    maxPriorityFeePerGas: bigint;
+                    isSystemTx?: undefined | undefined;
+                    mint?: undefined | undefined;
+                    sourceHash?: undefined | undefined;
+                }) & {};
+                type: "transaction";
+            };
+            readonly transactionReceipt: {
+                exclude: [] | undefined;
+                format: (args: viem_chains.OpStackRpcTransactionReceipt, action?: string | undefined) => {
+                    blobGasPrice?: bigint | undefined;
+                    blobGasUsed?: bigint | undefined;
+                    blockHash: viem.Hash;
+                    blockNumber: bigint;
+                    contractAddress: `0x${string}` | null | undefined;
+                    cumulativeGasUsed: bigint;
+                    effectiveGasPrice: bigint;
+                    from: `0x${string}`;
+                    gasUsed: bigint;
+                    logs: viem.Log<bigint, number, false>[];
+                    logsBloom: viem.Hex;
+                    root?: `0x${string}` | undefined;
+                    status: "success" | "reverted";
+                    to: `0x${string}` | null;
+                    transactionHash: viem.Hash;
+                    transactionIndex: number;
+                    type: viem.TransactionType;
+                    l1GasPrice: bigint | null;
+                    l1GasUsed: bigint | null;
+                    l1Fee: bigint | null;
+                    l1FeeScalar: number | null;
+                } & {};
+                type: "transactionReceipt";
+            };
+        };
+        prepareTransactionRequest?: ((args: viem.PrepareTransactionRequestParameters, options: {
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<viem.PrepareTransactionRequestParameters>) | [fn: ((args: viem.PrepareTransactionRequestParameters, options: {
+            phase: "beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters";
+        }) => Promise<viem.PrepareTransactionRequestParameters>) | undefined, options: {
+            runAt: readonly ("beforeFillTransaction" | "beforeFillParameters" | "afterFillParameters")[];
+        }] | undefined;
+        serializers: {
+            readonly transaction: typeof viem_chains.serializeTransactionOpStack;
+        };
+        verifyHash?: ((client: viem.Client, parameters: viem.VerifyHashActionParameters) => Promise<viem.VerifyHashActionReturnType>) | undefined;
+        readonly network: "base-sepolia";
+    };
+};
+type NetworkType = keyof typeof CHAIN_CONFIG;
+/**
+ * Contract addresses by network
+ */
+declare const CONTRACT_ADDRESSES: Record<NetworkType, {
+    agentRegistry: Address;
+    exaToken: Address;
+    staking: Address;
+    router: Address;
+    vaultFactory: Address;
+    feeCollector: Address;
+    buyback: Address;
+    serviceEscrow: Address;
+}>;
+/**
+ * DEX router addresses on Base
+ */
+declare const DEX_ADDRESSES: {
+    readonly aerodromeRouter: Address;
+    readonly aerodromeSlipstream: Address;
+    readonly uniswapUniversalRouter: Address;
+    readonly uniswapV4Router: Address;
+    readonly WETH: Address;
+    readonly USDC: Address;
+};
+/**
+ * 0x API configuration
+ */
+declare const ZERO_X_CONFIG: {
+    readonly baseUrl: "https://api.0x.org";
+    readonly chainId: 8453;
+};
+/**
+ * Exagent API configuration
+ */
+declare const EXAGENT_API_CONFIG: {
+    readonly mainnet: "https://api.exagent.io";
+    readonly testnet: "https://api.testnet.exagent.io";
+};
+
+/**
+ * Configuration for ExagentClient
+ */
+interface ExagentClientConfig {
+    /** Network to connect to */
+    network?: NetworkType;
+    /** Private key for the agent's wallet */
+    privateKey?: `0x${string}`;
+    /** Pre-configured wallet client */
+    walletClient?: WalletClient;
+    /** RPC URL override */
+    rpcUrl?: string;
+    /** Exagent API key (optional, for enhanced features) */
+    apiKey?: string;
+}
+/**
+ * Main client for interacting with Exagent
+ *
+ * @example
+ * ```typescript
+ * import { ExagentClient } from '@exagent/sdk';
+ *
+ * const exagent = new ExagentClient({
+ *   privateKey: process.env.AGENT_PRIVATE_KEY,
+ *   network: 'mainnet',
+ * });
+ *
+ * // Register agent
+ * const agentId = await exagent.register({
+ *   name: 'My Trading Agent',
+ *   description: 'Momentum-based trading strategy',
+ *   capabilities: ['spot_trading'],
+ * });
+ *
+ * // Execute trade
+ * const route = await exagent.getRoute({
+ *   tokenIn: WETH,
+ *   tokenOut: USDC,
+ *   amountIn: parseEther('1'),
+ * });
+ * await exagent.executeTrade(route);
+ * ```
+ */
+declare class ExagentClient {
+    private readonly publicClient;
+    private readonly walletClient;
+    private readonly account;
+    private readonly network;
+    private readonly apiKey?;
+    readonly registry: ExagentRegistry;
+    readonly staking: ExagentStaking;
+    private _agentId?;
+    constructor(config: ExagentClientConfig);
+    /**
+     * Register as a new agent on Exagent
+     * @param metadata Agent metadata (will be uploaded to IPFS)
+     * @returns The assigned agent ID
+     * @throws Error if wallet already owns an agent (one agent per wallet rule)
+     */
+    register(metadata: AgentMetadata): Promise<bigint>;
+    /**
+     * Check if an agent name is available for registration
+     * @param name The name to check
+     * @returns True if the name is available
+     */
+    isNameAvailable(name: string): Promise<boolean>;
+    /**
+     * Get agent by name (returns 0 if not found)
+     * @param name The agent name to look up
+     * @returns Agent ID or 0 if not found
+     */
+    getAgentByName(name: string): Promise<bigint>;
+    /**
+     * Get the current agent's ID (if registered)
+     */
+    getAgentId(): Promise<bigint | undefined>;
+    /**
+     * Get agent profile
+     * @param agentId Optional agent ID (defaults to current agent)
+     */
+    getAgent(agentId?: bigint): Promise<AgentProfile>;
+    /**
+     * Link an additional wallet to this agent
+     * @param wallet Wallet address to link
+     * @param signMessage Function to sign a message with the wallet
+     */
+    linkWallet(wallet: Address, signMessage: (message: string) => Promise<`0x${string}`>): Promise<Hash>;
+    /**
+     * Get all wallets linked to this agent
+     */
+    getLinkedWallets(): Promise<Address[]>;
+    /**
+     * Get optimal DEX route for a trade
+     * Uses 0x API for aggregation across Aerodrome, Uniswap, etc.
+     */
+    getRoute(intent: TradeIntent): Promise<RouteQuote>;
+    /**
+     * Get price quote without transaction data (faster)
+     */
+    getPrice(tokenIn: Address, tokenOut: Address, amountIn: bigint): Promise<PriceQuote>;
+    /**
+     * Execute a trade using a pre-fetched route
+     * @param route Route quote from getRoute()
+     * @param options Trade execution options
+     * @returns Transaction hash
+     */
+    executeTrade(route: RouteQuote, options?: {
+        validateSlippage?: boolean;
+    }): Promise<Hash>;
+    /**
+     * Get and execute a trade in one call
+     * Convenience method that fetches route and executes
+     */
+    swap(intent: TradeIntent): Promise<{
+        hash: Hash;
+        route: RouteQuote;
+    }>;
+    /**
+     * Broadcast a trade intent to the network
+     * Other agents can see this and potentially provide better execution
+     */
+    broadcastIntent(intent: TradeIntent): Promise<void>;
+    /**
+     * Execute a trade through ExagentRouter for full attribution
+     *
+     * This is the recommended way for agents to trade. All trades routed through
+     * the ExagentRouter emit TradeExecuted events that are captured by the indexer
+     * for accurate performance tracking and rankings.
+     *
+     * @param intent Trade parameters
+     * @returns Trade result with transaction hash
+     *
+     * @example
+     * ```typescript
+     * const result = await exagent.trade({
+     *   tokenIn: WETH,
+     *   tokenOut: USDC,
+     *   amountIn: parseEther('1'),
+     *   maxSlippageBps: 50,
+     * });
+     * console.log('Trade submitted:', result.hash);
+     * ```
+     */
+    trade(intent: Omit<TradeIntent, 'action'>): Promise<TradeResult>;
+    /**
+     * Build a router trade transaction without executing
+     * Useful for simulation or multi-step workflows
+     */
+    buildRouterTrade(intent: Omit<TradeIntent, 'action'>, agentId?: bigint): Promise<RouterTradeResponse>;
+    /**
+     * Approve token spending for router
+     */
+    private approveToken;
+    /**
+     * Encode ERC20 approve calldata
+     */
+    private encodeApprove;
+    /**
+     * Request a service from another agent
+     */
+    requestService(request: ServiceRequest): Promise<{
+        requestId: string;
+    }>;
+    /**
+     * List available services
+     */
+    listServices(serviceType?: string): Promise<unknown[]>;
+    /**
+     * Get agent leaderboard
+     */
+    getLeaderboard(options?: {
+        category?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<AgentProfile[]>;
+    /**
+     * Get a vault interface for interacting with an ExagentVault
+     * @param vaultAddress The vault contract address
+     * @returns ExagentVault instance
+     */
+    getVault(vaultAddress: Address): ExagentVault;
+    /**
+     * List all vaults for a given agent
+     * @param agentId Agent ID to get vaults for
+     * @returns Array of vault summaries
+     */
+    getAgentVaults(agentId?: bigint): Promise<VaultSummary[]>;
+    /**
+     * List all vaults the user has positions in
+     * @param userAddress User address (defaults to connected wallet)
+     * @returns Array of vault summaries with user position info
+     */
+    getUserVaults(userAddress?: Address): Promise<VaultSummary[]>;
+    /**
+     * List top performing vaults
+     * @param options Filter options
+     * @returns Array of vault summaries sorted by performance
+     */
+    getTopVaults(options?: {
+        asset?: Address;
+        minTvl?: bigint;
+        period?: '7d' | '30d' | '90d' | 'all';
+        limit?: number;
+    }): Promise<VaultSummary[]>;
+    /**
+     * Deposit into a vault
+     * @param vaultAddress Vault contract address
+     * @param amount Amount of underlying asset to deposit
+     * @returns Transaction hash
+     */
+    depositToVault(vaultAddress: Address, amount: bigint): Promise<Hash>;
+    /**
+     * Withdraw from a vault
+     * @param vaultAddress Vault contract address
+     * @param assets Amount of underlying asset to withdraw
+     * @returns Transaction hash
+     */
+    withdrawFromVault(vaultAddress: Address, assets: bigint): Promise<Hash>;
+    /**
+     * Redeem shares from a vault
+     * @param vaultAddress Vault contract address
+     * @param shares Amount of shares to redeem
+     * @returns Transaction hash
+     */
+    redeemFromVault(vaultAddress: Address, shares: bigint): Promise<Hash>;
+    /**
+     * Stake EXA tokens to receive vEXA voting power
+     * @param amount Amount of EXA to stake (in wei)
+     * @param lockDuration Lock duration in seconds (30 days to 2 years)
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Stake 1000 EXA for 6 months
+     * const tx = await exagent.stakeExa(
+     *   parseEther('1000'),
+     *   ExagentStaking.LOCK_6_MONTHS
+     * );
+     * ```
+     */
+    stakeExa(amount: bigint, lockDuration: bigint): Promise<Hash>;
+    /**
+     * Unstake EXA tokens after lock expires
+     * @returns Transaction hash
+     */
+    unstakeExa(): Promise<Hash>;
+    /**
+     * Get staking info for the connected wallet
+     * @returns Staking info including amount, unlock time, and vEXA balance
+     */
+    getStakingInfo(): Promise<StakingInfo>;
+    /**
+     * Get current vEXA balance for the connected wallet
+     * @returns Current vEXA balance (with time decay applied)
+     */
+    getVeEXABalance(): Promise<bigint>;
+    /**
+     * Delegate vEXA voting power to an agent
+     * @param agentId The agent ID to delegate to
+     * @returns Transaction hash
+     */
+    delegateToAgent(agentId: bigint): Promise<Hash>;
+    /**
+     * Get delegation stats for an agent
+     * @param agentId The agent ID to check
+     * @returns Delegation info with total vEXA and delegator count
+     */
+    getAgentDelegation(agentId: bigint): Promise<DelegationInfo>;
+    /**
+     * Claim all pending staking rewards (EXA + multi-token)
+     * @returns Transaction hashes for EXA and multi-token claims
+     */
+    claimAllRewards(): Promise<{
+        exaRewards: Hash;
+        multiTokenRewards: Hash;
+    }>;
+    /**
+     * Get the agent's wallet address
+     */
+    get address(): Address;
+    private uploadMetadata;
+    private signIntent;
+    private parseAgentIdFromReceipt;
+}
+
+/**
+ * ExagentVaultFactory ABI
+ */
+declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
+    readonly type: "function";
+    readonly name: "owner";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "registry";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "router";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "minimumVeEXARequired";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "eXABurnFee";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "allowedAssets";
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "vaults";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "agentVaultCount";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "canCreateVault";
+    readonly inputs: readonly [{
+        readonly name: "creator";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "canCreate";
+        readonly type: "bool";
+    }, {
+        readonly name: "reason";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getVaultCreationRequirements";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly name: "veXARequired";
+        readonly type: "uint256";
+    }, {
+        readonly name: "burnFee";
+        readonly type: "uint256";
+    }, {
+        readonly name: "stakingContract";
+        readonly type: "address";
+    }, {
+        readonly name: "exaToken";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "createVault";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+    }, {
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+    }, {
+        readonly name: "feeRecipient";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "event";
+    readonly name: "VaultCreated";
+    readonly inputs: readonly [{
+        readonly name: "vault";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "agentId";
+        readonly type: "uint256";
+        readonly indexed: true;
+    }, {
+        readonly name: "asset";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "creator";
+        readonly type: "address";
+        readonly indexed: false;
+    }, {
+        readonly name: "name";
+        readonly type: "string";
+        readonly indexed: false;
+    }, {
+        readonly name: "symbol";
+        readonly type: "string";
+        readonly indexed: false;
+    }];
+}, {
+    readonly type: "event";
+    readonly name: "AllowedAssetUpdated";
+    readonly inputs: readonly [{
+        readonly name: "asset";
+        readonly type: "address";
+        readonly indexed: true;
+    }, {
+        readonly name: "allowed";
+        readonly type: "bool";
+        readonly indexed: false;
+    }];
+}];
+/**
+ * Vault creation requirements from the factory
+ */
+interface VaultCreationRequirements {
+    veXARequired: bigint;
+    burnFee: bigint;
+    stakingContract: Address;
+    exaToken: Address;
+    /** Whether requirements are effectively bypassed (testnet mode) */
+    isBypassed: boolean;
+}
+/**
+ * Result of checking if an address can create a vault
+ */
+interface CanCreateVaultResult {
+    canCreate: boolean;
+    reason: string;
+}
+/**
+ * Options for creating a vault
+ */
+interface CreateVaultOptions {
+    agentId: bigint;
+    asset: Address;
+    name: string;
+    symbol: string;
+    feeRecipient?: Address;
+}
+/**
+ * ExagentVaultFactory SDK class for vault creation and management
+ */
+declare class ExagentVaultFactory {
+    readonly address: Address;
+    private readonly publicClient;
+    private readonly walletClient?;
+    private readonly chain;
+    private readonly account?;
+    constructor(factoryAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
+    /**
+     * Get vault creation requirements
+     */
+    getRequirements(): Promise<VaultCreationRequirements>;
+    /**
+     * Check if an address can create a vault
+     * @param creator Address to check
+     */
+    canCreateVault(creator: Address): Promise<CanCreateVaultResult>;
+    /**
+     * Check if an asset is whitelisted for vault creation
+     * @param asset Asset address to check
+     */
+    isAssetAllowed(asset: Address): Promise<boolean>;
+    /**
+     * Get existing vault for an agent and asset
+     * @param agentId Agent ID
+     * @param asset Asset address
+     * @returns Vault address or zero address if none exists
+     */
+    getVault(agentId: bigint, asset: Address): Promise<Address>;
+    /**
+     * Get count of vaults for an agent
+     * @param agentId Agent ID
+     */
+    getAgentVaultCount(agentId: bigint): Promise<bigint>;
+    /**
+     * Check if agent already has a vault for an asset
+     * @param agentId Agent ID
+     * @param asset Asset address
+     */
+    hasVault(agentId: bigint, asset: Address): Promise<boolean>;
+    /**
+     * Create a new vault for an agent
+     * @param options Vault creation options
+     * @returns Transaction hash
+     */
+    createVault(options: CreateVaultOptions): Promise<Hash>;
+    /**
+     * Check all requirements and create a vault if possible
+     * Returns detailed status about each requirement
+     */
+    checkAndCreateVault(agentId: bigint, asset: Address, name: string, symbol: string, feeRecipient?: Address): Promise<{
+        success: boolean;
+        vaultAddress?: Address;
+        txHash?: Hash;
+        error?: string;
+        checks: {
+            canCreate: boolean;
+            canCreateReason: string;
+            assetAllowed: boolean;
+            hasExistingVault: boolean;
+        };
+    }>;
+}
+
+/**
+ * Quick access to testnet (Base Sepolia) contract addresses
+ * Use these when interacting with contracts directly via viem
+ */
+declare const TESTNET_ADDRESSES: {
+    readonly registry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C";
+    readonly token: "0x66c39b0ad96B3f5eE198Fef913c6636353a48A87";
+    readonly staking: "0x439441468e1b1b616E9D36b80969C241F261A011";
+    readonly router: "0xc0c27eEE047E414CD716D06C2444CF2073113d5C";
+    readonly vaultFactory: "0x5c099daaE33801a907Bb57011c6749655b55dc75";
+    readonly feeCollector: "0xcB57b03a50df054b9C738Df1324C17A4fDe4fe46";
+    readonly buyback: "0x35cdEa810A130A846265682e5c71A68A507aB895";
+    readonly serviceEscrow: "0x74a3496b148DEE735ac388299aF9Ac2F7C4EdCBf";
+    readonly usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e";
+};
+
+export { type AgentMetadata, type AgentProfile, CHAIN_CONFIG, CONTRACT_ADDRESSES, type CanCreateVaultResult, type CreateVaultOptions, DEX_ADDRESSES, DISCOUNT_TIERS, type DelegationInfo$1 as DelegationInfo, type DelegationInfo as DelegationInfoExtended, type DiscountTier$1 as DiscountTier, type DiscountTier as DiscountTierType, EXAGENT_API_CONFIG, EXAGENT_STAKING_ABI, EXAGENT_VAULT_FACTORY_ABI, ExagentClient, type ExagentClientConfig, ExagentRegistry, ExagentStaking, ExagentVault, ExagentVaultFactory, type NetworkType, type PerformanceSnapshot, type PriceQuote, type RouteQuote, type RouteStep, type RouterTradeResponse, type ServiceRequest, type StakeInfo, type StakingInfo$1 as StakingInfo, type StakingInfo as StakingInfoExtended, TESTNET_ADDRESSES, type TradeIntent, type TradeResult, type UserVaultPosition, type VaultActivityEntry, type VaultConfig, type VaultCreationRequirements, type VaultInfo, type VaultPosition, type VaultSummary, type VaultTradeEntry, type WithdrawalRequest, ZERO_X_CONFIG };