@exagent/sdk 0.1.2 → 0.1.4

package/dist/index.d.ts

@@ -2,6 +2,52 @@ import * as viem from 'viem';
 import { Address, Hash, Chain, Account, Hex, WalletClient } from 'viem';
 import * as viem_chains from 'viem/chains';
 
+/**
+ * ERC-8004 Global Agent Identifier
+ * Format: eip155:{chainId}:{registryAddress}:{agentId}
+ *
+ * This creates a universally unique identifier for any agent across
+ * all EVM chains, enabling cross-protocol agent discovery.
+ *
+ * @example
+ * ```
+ * // Base mainnet agent #42
+ * "eip155:8453:0xABC...DEF:42"
+ *
+ * // Base Sepolia testnet agent #7
+ * "eip155:84532:0x123...789:7"
+ * ```
+ */
+type GlobalAgentId = `eip155:${number}:${Address}:${number}`;
+/**
+ * Build an ERC-8004 compliant global agent identifier
+ *
+ * @param chainId - EVM chain ID (8453 for Base, 84532 for Base Sepolia)
+ * @param registryAddress - ExagentRegistry contract address
+ * @param agentId - On-chain agent ID (from ExagentRegistry)
+ * @returns Global agent identifier string
+ *
+ * @example
+ * ```typescript
+ * import { buildGlobalAgentId } from '@exagent/sdk';
+ *
+ * const globalId = buildGlobalAgentId(8453, '0xABC...DEF', 42);
+ * // => "eip155:8453:0xABC...DEF:42"
+ * ```
+ */
+declare function buildGlobalAgentId(chainId: number, registryAddress: Address, agentId: number | bigint): GlobalAgentId;
+/**
+ * Parse an ERC-8004 global agent identifier into its components
+ *
+ * @param globalId - The global agent identifier string
+ * @returns Parsed components: chainId, registryAddress, agentId
+ * @throws Error if the format is invalid
+ */
+declare function parseGlobalAgentId(globalId: string): {
+    chainId: number;
+    registryAddress: Address;
+    agentId: number;
+};
 /**
  * Agent profile as stored on-chain
  */
@@ -27,7 +73,7 @@ interface AgentMetadata {
     website?: string;
     social?: {
         twitter?: string;
-        moltbook?: string;
+        github?: string;
     };
 }
 /**
@@ -176,23 +222,6 @@ interface StakingInfo$1 extends StakeInfo {
     /** 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
  */
@@ -267,7 +296,7 @@ interface VaultTradeEntry {
  * Wrapper for ExagentRegistry contract interactions
  */
 declare class ExagentRegistry {
-    private readonly address;
+    readonly address: Address;
     private readonly publicClient;
     private readonly walletClient?;
     private readonly chain;
@@ -277,9 +306,12 @@ declare class ExagentRegistry {
      * Register a new agent
      * @param name Unique agent name (3-32 chars, alphanumeric + spaces/hyphens/underscores)
      * @param metadataURI IPFS URI for agent metadata
+     * @param riskUniverse Risk tier: 0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier
+     * @param maxPositionSizeBps Maximum position size in basis points (1-10000)
+     * @param maxDailyLossBps Maximum daily loss in basis points (1-10000)
      * @returns Transaction hash
      */
-    register(name: string, metadataURI: string): Promise<Hash>;
+    register(name: string, metadataURI: string, riskUniverse?: number, maxPositionSizeBps?: bigint, maxDailyLossBps?: bigint): Promise<Hash>;
     /**
      * Check if a name is available for registration
      * @param name The name to check
@@ -357,13 +389,13 @@ declare class ExagentRegistry {
      */
     getNextAgentId(): Promise<bigint>;
     /**
-     * Generate the raw packed message bytes for wallet linking.
-     * Must match the contract's abi.encodePacked format exactly:
-     *   keccak256(abi.encodePacked("Link wallet ", wallet, " to Exagent ", agentId, " nonce ", nonce))
+     * Generate the message hash for wallet linking.
+     * Matches the contract's keccak256(abi.encodePacked(...)) exactly.
+     * Sign the returned hash with signMessage({ raw: hash }) to produce a valid signature.
      * @param wallet The wallet to link
      * @param agentId The agent ID to link to
      * @param nonce The current nonce for the wallet
-     * @returns Raw packed bytes as hex string
+     * @returns keccak256 hash of the packed message (32 bytes)
      */
     static generateLinkMessage(wallet: Address, agentId: bigint, nonce: bigint): Hex;
     /**
@@ -429,6 +461,38 @@ declare class ExagentRegistry {
      * @returns keccak256 hash of the config
      */
     static calculateConfigHash(provider: string, model: string): `0x${string}`;
+    /**
+     * Retire an agent — marks it as retired, unlinks all wallets, allows new agent registration
+     * @param agentId The agent's ID
+     * @returns Transaction hash
+     */
+    retireAgent(agentId: bigint): Promise<Hash>;
+    /**
+     * Check if an agent is retired
+     * @param agentId The agent's ID
+     * @returns True if agent is retired
+     */
+    isRetired(agentId: bigint): Promise<boolean>;
+    /**
+     * Check if a token trade is allowed for an agent's risk universe
+     * @param agentId The agent's ID
+     * @param token The token address to check
+     * @param aggregator The aggregator being used (for trusted aggregator bypass)
+     * @returns True if the trade is allowed
+     */
+    isTradeAllowed(agentId: bigint, token: Address, aggregator: Address): Promise<boolean>;
+    /**
+     * Get the risk universe for an agent
+     * @param agentId The agent's ID
+     * @returns Risk universe (0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier)
+     */
+    getRiskUniverse(agentId: bigint): Promise<number>;
+    /**
+     * Get trade count for an agent
+     * @param agentId The agent's ID
+     * @returns Number of recorded trades
+     */
+    getTradeCount(agentId: bigint): Promise<bigint>;
 }
 
 /**
@@ -581,7 +645,7 @@ declare class ExagentVault {
 }
 
 /**
- * ExagentStaking ABI
+ * ExagentStaking ABI (Mainnet — Two-Phase: Deposit → Lock)
  */
 declare const EXAGENT_STAKING_ABI: readonly [{
     readonly type: "function";
@@ -593,7 +657,15 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "totalStaked";
+    readonly name: "totalDeposited";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "totalLocked";
     readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly type: "uint256";
@@ -609,10 +681,10 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "registry";
+    readonly name: "totalEffectiveVeEXA";
     readonly inputs: readonly [];
     readonly outputs: readonly [{
-        readonly type: "address";
+        readonly type: "uint256";
     }];
     readonly stateMutability: "view";
 }, {
@@ -631,6 +703,14 @@ declare const EXAGENT_STAKING_ABI: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VAULT_ACCESS_THRESHOLD";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "PRECISION";
@@ -641,20 +721,32 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "stake";
+    readonly name: "deposit";
     readonly inputs: readonly [{
         readonly name: "amount";
         readonly type: "uint256";
-    }, {
-        readonly name: "lockDuration";
+    }];
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+}, {
+    readonly type: "function";
+    readonly name: "withdraw";
+    readonly inputs: readonly [{
+        readonly name: "amount";
         readonly type: "uint256";
     }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "unstake";
-    readonly inputs: readonly [];
+    readonly name: "lock";
+    readonly inputs: readonly [{
+        readonly name: "amount";
+        readonly type: "uint256";
+    }, {
+        readonly name: "lockDuration";
+        readonly type: "uint256";
+    }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
@@ -668,52 +760,51 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "claimRewards";
+    readonly name: "unlock";
     readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "claimRewardsMulti";
+    readonly name: "emergencyWithdraw";
     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 name: "claimRewards";
+    readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "delegate";
-    readonly inputs: readonly [{
-        readonly name: "agentId";
-        readonly type: "uint256";
-    }];
+    readonly name: "claimRewardsMulti";
+    readonly inputs: readonly [];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "undelegate";
-    readonly inputs: readonly [];
+    readonly name: "claimRewardsToken";
+    readonly inputs: readonly [{
+        readonly name: "token";
+        readonly type: "address";
+    }];
     readonly outputs: readonly [];
     readonly stateMutability: "nonpayable";
 }, {
     readonly type: "function";
-    readonly name: "redelegate";
+    readonly name: "depositedAmount";
     readonly inputs: readonly [{
-        readonly name: "newAgentId";
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
         readonly type: "uint256";
     }];
-    readonly outputs: readonly [];
-    readonly stateMutability: "nonpayable";
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "stakes";
+    readonly name: "locks";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
@@ -743,6 +834,17 @@ declare const EXAGENT_STAKING_ABI: readonly [{
         readonly type: "uint256";
     }];
     readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "getEffectiveVeEXA";
+    readonly inputs: readonly [{
+        readonly name: "user";
+        readonly type: "address";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
 }, {
     readonly type: "function";
     readonly name: "calculateVeEXA";
@@ -784,64 +886,45 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "getDelegatedAgent";
+    readonly name: "getEarningsTier";
     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 name: "multiplierBps";
         readonly type: "uint256";
     }, {
-        readonly name: "count";
-        readonly type: "uint256";
+        readonly name: "tierName";
+        readonly type: "string";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "getDiscountTier";
+    readonly name: "getEmergencyWithdrawPenalty";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
     }];
     readonly outputs: readonly [{
-        readonly name: "discountBps";
+        readonly name: "penaltyBps";
         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 name: "hasVaultAccess";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
     }];
     readonly outputs: readonly [{
-        readonly type: "uint256";
+        readonly type: "bool";
     }];
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "userDelegatedVeEXA";
+    readonly name: "getUnlockedBalance";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
@@ -852,24 +935,10 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     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 name: "getRewardTokens";
+    readonly inputs: readonly [];
     readonly outputs: readonly [{
-        readonly type: "uint256";
+        readonly type: "address[]";
     }];
     readonly stateMutability: "view";
 }, {
@@ -885,7 +954,7 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "event";
-    readonly name: "Staked";
+    readonly name: "Deposited";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
@@ -895,21 +964,13 @@ declare const EXAGENT_STAKING_ABI: readonly [{
         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 name: "totalDeposited";
         readonly type: "uint256";
         readonly indexed: false;
     }];
 }, {
     readonly type: "event";
-    readonly name: "Unstaked";
+    readonly name: "Withdrawn";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
@@ -918,26 +979,38 @@ declare const EXAGENT_STAKING_ABI: readonly [{
         readonly name: "amount";
         readonly type: "uint256";
         readonly indexed: false;
+    }, {
+        readonly name: "totalDeposited";
+        readonly type: "uint256";
+        readonly indexed: false;
     }];
 }, {
     readonly type: "event";
-    readonly name: "LockExtended";
+    readonly name: "Locked";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
         readonly indexed: true;
     }, {
-        readonly name: "newUnlockTime";
+        readonly name: "amount";
         readonly type: "uint256";
         readonly indexed: false;
     }, {
-        readonly name: "newVeEXABalance";
+        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: "RewardsClaimed";
+    readonly name: "Unlocked";
     readonly inputs: readonly [{
         readonly name: "user";
         readonly type: "address";
@@ -949,33 +1022,49 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     }];
 }, {
     readonly type: "event";
-    readonly name: "Delegated";
+    readonly name: "EmergencyWithdrawal";
     readonly inputs: readonly [{
-        readonly name: "delegator";
+        readonly name: "user";
         readonly type: "address";
         readonly indexed: true;
     }, {
-        readonly name: "agentId";
+        readonly name: "returned";
         readonly type: "uint256";
-        readonly indexed: true;
+        readonly indexed: false;
+    }, {
+        readonly name: "penalty";
+        readonly type: "uint256";
+        readonly indexed: false;
     }, {
-        readonly name: "veEXAAmount";
+        readonly name: "penaltyBps";
         readonly type: "uint256";
         readonly indexed: false;
     }];
 }, {
     readonly type: "event";
-    readonly name: "Undelegated";
+    readonly name: "LockExtended";
     readonly inputs: readonly [{
-        readonly name: "delegator";
+        readonly name: "user";
         readonly type: "address";
         readonly indexed: true;
     }, {
-        readonly name: "agentId";
+        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: "veEXAAmount";
+        readonly name: "amount";
         readonly type: "uint256";
         readonly indexed: false;
     }];
@@ -997,16 +1086,29 @@ declare const EXAGENT_STAKING_ABI: readonly [{
     }];
 }];
 /**
- * Staking info for a user
+ * Deposit info for a user (Phase 1 — no lock)
  */
-interface StakingInfo {
-    /** Amount of EXA staked */
+interface DepositInfo {
+    /** Total EXA deposited (locked + unlocked) */
+    deposited: bigint;
+    /** EXA currently locked */
+    locked: bigint;
+    /** EXA available for withdrawal or locking */
+    unlocked: bigint;
+    /** Whether user has vault access (meets deposit threshold) */
+    hasVaultAccess: boolean;
+}
+/**
+ * Lock info for a user (Phase 2)
+ */
+interface LockInfo {
+    /** Amount of EXA locked */
     amount: bigint;
-    /** Timestamp when stake can be withdrawn */
+    /** Timestamp when lock expires */
     unlockTime: bigint;
     /** Original lock duration in seconds */
     lockDuration: bigint;
-    /** vEXA balance at stake time (before time decay) */
+    /** vEXA balance at lock time (before time decay) */
     vEXABalance: bigint;
     /** Current vEXA balance (with time decay applied) */
     currentVeEXA: bigint;
@@ -1016,29 +1118,32 @@ interface StakingInfo {
     remainingLockTime: bigint;
 }
 /**
- * Delegation info for an agent
+ * Combined staking info (deposit + lock)
  */
-interface DelegationInfo {
-    /** Total vEXA delegated to this agent */
-    totalVeEXA: bigint;
-    /** Number of unique delegators */
-    delegatorCount: bigint;
+interface StakingInfo {
+    /** Deposit phase info */
+    deposit: DepositInfo;
+    /** Lock phase info (null if no active lock) */
+    lock: LockInfo | null;
 }
 /**
- * Discount tier for trading fee reductions
+ * Earnings tier info from the mainnet staking contract
  */
-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;
-};
+interface EarningsTierInfo {
+    /** Earnings multiplier in basis points (e.g. 10000 = 1x, 25000 = 2.5x) */
+    multiplierBps: bigint;
+    /** Tier name: None, Bronze, Silver, Gold, Platinum, Diamond */
+    tierName: string;
+}
 /**
- * ExagentStaking SDK interface for vEXA staking, rewards, and delegation
+ * ExagentStaking SDK — Two-Phase Staking: Deposit for Vault Access, Lock for vEXA + Rewards
+ *
+ * Phase 1: deposit() → withdraw()
+ *   Deposit EXA to get vault access. No lock, no vEXA, no rewards. Instant withdraw.
+ *
+ * Phase 2: lock() → unlock() / emergencyWithdraw()
+ *   Lock deposited EXA for vEXA voting power and tiered earnings.
+ *   unlock() after expiry (0% penalty). emergencyWithdraw() before expiry (50%→20% penalty).
  */
 declare class ExagentStaking {
     readonly address: Address;
@@ -1048,33 +1153,58 @@ declare class ExagentStaking {
     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)
+     * Deposit EXA tokens for vault access (no lock required)
+     * @param amount Amount of EXA to deposit (in wei)
      * @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
-     * );
+     * // Deposit 1000 EXA to unlock vault access
+     * const tx = await staking.deposit(parseEther('1000'));
      * ```
      */
-    stake(amount: bigint, lockDuration: bigint): Promise<Hash>;
+    deposit(amount: bigint): Promise<Hash>;
     /**
-     * Unstake EXA tokens after lock expires
+     * Withdraw unlocked EXA tokens (instant, no penalty)
+     * @param amount Amount of EXA to withdraw (in wei)
      * @returns Transaction hash
-     * @throws Error if lock has not expired
      */
-    unstake(): Promise<Hash>;
+    withdraw(amount: bigint): Promise<Hash>;
+    /**
+     * Lock deposited EXA to receive vEXA voting power and earn rewards
+     * @param amount Amount of deposited EXA to lock (in wei)
+     * @param lockDuration Lock duration in seconds (30 days to 2 years)
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Lock 1000 EXA for 6 months
+     * const tx = await staking.lock(
+     *   parseEther('1000'),
+     *   ExagentStaking.LOCK_6_MONTHS
+     * );
+     * ```
+     */
+    lock(amount: bigint, lockDuration: bigint): 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>;
+    /**
+     * Unlock EXA after lock expires (normal path — no penalty)
+     * Returns locked amount to unlocked deposited balance.
+     * @returns Transaction hash
+     */
+    unlock(): Promise<Hash>;
+    /**
+     * Emergency withdrawal — instant exit from lock with graduated penalty
+     * Two-phase penalty: 50%→20% over the first quarter of the lock, then flat 20% until expiry.
+     * Penalty goes to treasury. Remaining returns to unlocked deposit balance.
+     * @returns Transaction hash
+     */
+    emergencyWithdraw(): Promise<Hash>;
     /**
      * Claim accumulated EXA rewards
      * @returns Transaction hash
@@ -1092,28 +1222,17 @@ declare class ExagentStaking {
      */
     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
+     * Get comprehensive staking info for a user (deposit + lock)
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Combined staking info
      */
-    redelegate(newAgentId: bigint): Promise<Hash>;
+    getStakingInfo(userAddress?: Address): Promise<StakingInfo>;
     /**
-     * Get comprehensive staking info for a user
+     * Get deposit info for a user
      * @param userAddress Address to check (defaults to connected wallet)
-     * @returns Staking info with amount, unlock time, and vEXA balance
+     * @returns Deposit info
      */
-    getStakeInfo(userAddress?: Address): Promise<StakingInfo>;
+    getDepositInfo(userAddress?: Address): Promise<DepositInfo>;
     /**
      * Get current vEXA balance (with time decay applied)
      * @param userAddress Address to check (defaults to connected wallet)
@@ -1121,26 +1240,29 @@ declare class ExagentStaking {
      */
     getVeEXABalance(userAddress?: Address): Promise<bigint>;
     /**
-     * Get the agent ID a user is delegating to
+     * Get effective vEXA (with tier multiplier applied)
      * @param userAddress Address to check (defaults to connected wallet)
-     * @returns Agent ID (0 if not delegating)
+     * @returns Effective vEXA balance
      */
-    getDelegatedAgent(userAddress?: Address): Promise<bigint>;
+    getEffectiveVeEXA(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
+     * Check if user has vault access (meets deposit threshold)
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns True if user can access vaults
      */
-    getAgentDelegation(agentId: bigint): Promise<DelegationInfo>;
+    hasVaultAccess(userAddress?: Address): Promise<boolean>;
     /**
-     * Get trading fee discount tier for a user
+     * Get earnings tier for a user (Bronze/Silver/Gold/Platinum/Diamond)
      * @param userAddress Address to check (defaults to connected wallet)
-     * @returns Discount tier name and basis points
+     * @returns Tier info with multiplier and name
      */
-    getDiscountTier(userAddress?: Address): Promise<{
-        tier: DiscountTier;
-        discountBps: bigint;
-    }>;
+    getEarningsTier(userAddress?: Address): Promise<EarningsTierInfo>;
+    /**
+     * Get current emergency withdrawal penalty for a user
+     * @param userAddress Address to check (defaults to connected wallet)
+     * @returns Penalty in basis points (5000 = 50% at lock start, ramps to 2000 over first 25% of lock, then flat 2000)
+     */
+    getEmergencyWithdrawPenalty(userAddress?: Address): Promise<bigint>;
     /**
      * Get pending EXA rewards for a user
      * @param userAddress Address to check (defaults to connected wallet)
@@ -1166,18 +1288,23 @@ declare class ExagentStaking {
      */
     isRewardToken(token: Address): Promise<boolean>;
     /**
-     * Get total staked EXA across all users
-     * @returns Total staked amount in wei
+     * Get total EXA deposited across all users
+     * @returns Total deposited amount in wei
+     */
+    getTotalDeposited(): Promise<bigint>;
+    /**
+     * Get total EXA locked across all users
+     * @returns Total locked amount in wei
      */
-    getTotalStaked(): Promise<bigint>;
+    getTotalLocked(): 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
+     * Calculate vEXA balance for a given lock (preview)
+     * @param amount Amount of EXA to lock
      * @param lockDuration Lock duration in seconds
      * @returns Expected vEXA balance
      */
@@ -1188,7 +1315,7 @@ declare class ExagentStaking {
      */
     getExaTokenAddress(): Promise<Address>;
     /**
-     * Approve EXA token spending for staking
+     * Approve EXA token spending for deposits
      * @param amount Amount to approve
      * @returns Transaction hash
      */
@@ -1209,6 +1336,8 @@ declare class ExagentStaking {
     static readonly LOCK_2_YEARS: bigint;
 }
 
+/** SDK version — sent to API for version gating */
+declare const SDK_VERSION = "0.1.4";
 declare const CHAIN_CONFIG: {
     readonly mainnet: {
         blockExplorers: {
@@ -1604,7 +1733,13 @@ declare const CHAIN_CONFIG: {
         formatters: {
             readonly block: {
                 exclude: [] | undefined;
-                format: (args: viem_chains.OpStackRpcBlock, action?: string | undefined) => {
+                format: (args: viem_chains.OpStackRpcBlock, action
+                /**
+                 * Validate that contract addresses are set for the given network.
+                 * Throws if mainnet addresses are all zero (not yet deployed).
+                 */
+                /** Phase 1 contracts — must be deployed on mainnet */
+                ?: string | undefined) => {
                     baseFeePerGas: bigint | null;
                     blobGasUsed: bigint;
                     difficulty: bigint;
@@ -1882,8 +2017,8 @@ declare const ZERO_X_CONFIG: {
  * Exagent API configuration
  */
 declare const EXAGENT_API_CONFIG: {
-    readonly mainnet: "https://api.exagent.io";
-    readonly testnet: "https://api.testnet.exagent.io";
+    readonly mainnet: "https://exagent-api.onrender.com";
+    readonly testnet: "https://exagent-api.onrender.com";
 };
 
 /**
@@ -1920,13 +2055,14 @@ interface ExagentClientConfig {
  *   capabilities: ['spot_trading'],
  * });
  *
- * // Execute trade
- * const route = await exagent.getRoute({
+ * // Execute trade (always through ExagentRouter for attribution + fees)
+ * const result = await exagent.trade({
  *   tokenIn: WETH,
  *   tokenOut: USDC,
  *   amountIn: parseEther('1'),
+ *   maxSlippageBps: 50,
  * });
- * await exagent.executeTrade(route);
+ * console.log('Trade submitted:', result.hash);
  * ```
  */
 declare class ExagentClient {
@@ -1939,6 +2075,8 @@ declare class ExagentClient {
     readonly staking: ExagentStaking;
     private _agentId?;
     constructor(config: ExagentClientConfig);
+    /** Standard headers for all API requests (includes SDK version for gating) */
+    private apiHeaders;
     /**
      * Register as a new agent on Exagent
      * @param metadata Agent metadata (will be uploaded to IPFS)
@@ -1970,50 +2108,25 @@ declare class ExagentClient {
     /**
      * Link an additional wallet to this agent
      * @param wallet Wallet address to link
-     * @param signMessage Function to sign a message with the wallet
+     * @param signMessage Function to sign the message hash with the wallet (use signMessage({ raw: hash }))
      */
-    linkWallet(wallet: Address, signMessage: (message: string) => Promise<`0x${string}`>): Promise<Hash>;
+    linkWallet(wallet: Address, signMessage: (message: {
+        raw: `0x${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
+     * Execute a trade through ExagentRouter
+     *
+     * All trades MUST go through the ExagentRouter. This ensures:
+     * - Trade attribution for leaderboard ranking
+     * - Protocol fee collection (0.2%)
+     * - On-chain performance tracking
+     * - Token whitelist enforcement per risk universe
      *
-     * 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.
+     * There is no way to trade outside the router. This is by design.
      *
      * @param intent Trade parameters
      * @returns Trade result with transaction hash
@@ -2112,48 +2225,79 @@ declare class ExagentClient {
      */
     redeemFromVault(vaultAddress: Address, shares: bigint): Promise<Hash>;
     /**
-     * Stake EXA tokens to receive vEXA voting power
-     * @param amount Amount of EXA to stake (in wei)
+     * Deposit EXA tokens for vault access (no lock required)
+     * @param amount Amount of EXA to deposit (in wei)
+     * @returns Transaction hash
+     *
+     * @example
+     * ```typescript
+     * // Deposit 1000 EXA to unlock vault access
+     * const tx = await exagent.depositExa(parseEther('1000'));
+     * ```
+     */
+    depositExa(amount: bigint): Promise<Hash>;
+    /**
+     * Withdraw unlocked EXA tokens (instant, no penalty)
+     * @param amount Amount of EXA to withdraw (in wei)
+     * @returns Transaction hash
+     */
+    withdrawExa(amount: bigint): Promise<Hash>;
+    /**
+     * Lock deposited EXA to receive vEXA voting power and earn rewards
+     * @param amount Amount of deposited EXA to lock (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(
+     * // Lock 1000 EXA for 6 months
+     * const tx = await exagent.lockExa(
      *   parseEther('1000'),
      *   ExagentStaking.LOCK_6_MONTHS
      * );
      * ```
      */
-    stakeExa(amount: bigint, lockDuration: bigint): Promise<Hash>;
+    lockExa(amount: bigint, lockDuration: bigint): Promise<Hash>;
     /**
-     * Unstake EXA tokens after lock expires
+     * Unlock EXA after lock expires (no penalty)
      * @returns Transaction hash
      */
-    unstakeExa(): Promise<Hash>;
+    unlockExa(): Promise<Hash>;
     /**
-     * Get staking info for the connected wallet
-     * @returns Staking info including amount, unlock time, and vEXA balance
+     * Emergency withdrawal from active lock (graduated 50%→20% penalty)
+     * @returns Transaction hash
+     */
+    emergencyWithdrawExa(): Promise<Hash>;
+    /**
+     * Get comprehensive staking info (deposit + lock) for the connected wallet
+     * @returns Staking info including deposit status and lock status
      */
     getStakingInfo(): Promise<StakingInfo>;
+    /**
+     * Get deposit info for the connected wallet
+     * @returns Deposit info (deposited, locked, unlocked, vault access)
+     */
+    getDepositInfo(): Promise<DepositInfo>;
     /**
      * 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
+     * Check if connected wallet has vault access (meets deposit threshold)
+     * @returns True if user can access vaults
+     */
+    hasVaultAccess(): Promise<boolean>;
+    /**
+     * Get earnings tier for the connected wallet
+     * @returns Tier info with multiplier and name
      */
-    delegateToAgent(agentId: bigint): Promise<Hash>;
+    getEarningsTier(): Promise<EarningsTierInfo>;
     /**
-     * Get delegation stats for an agent
-     * @param agentId The agent ID to check
-     * @returns Delegation info with total vEXA and delegator count
+     * Get emergency withdrawal penalty for the connected wallet
+     * @returns Penalty in basis points (5000 = 50% at start, 2000 = 20% near expiry)
      */
-    getAgentDelegation(agentId: bigint): Promise<DelegationInfo>;
+    getEmergencyWithdrawPenalty(): Promise<bigint>;
     /**
      * Claim all pending staking rewards (EXA + multi-token)
      * @returns Transaction hashes for EXA and multi-token claims
@@ -2162,6 +2306,33 @@ declare class ExagentClient {
         exaRewards: Hash;
         multiTokenRewards: Hash;
     }>;
+    /**
+     * Get the ERC-8004 global agent identifier for the current agent
+     *
+     * Format: eip155:{chainId}:{registryAddress}:{agentId}
+     *
+     * This creates a universally unique identifier that can be used for
+     * cross-protocol agent discovery and interoperability.
+     *
+     * @returns The global agent ID string
+     * @throws Error if agent is not registered
+     *
+     * @example
+     * ```typescript
+     * const globalId = await exagent.getGlobalAgentId();
+     * // => "eip155:8453:0xABC...DEF:42"
+     * ```
+     */
+    getGlobalAgentId(): Promise<GlobalAgentId>;
+    /**
+     * Build a global agent ID for any agent (static utility)
+     *
+     * @param chainId - EVM chain ID
+     * @param registryAddress - ExagentRegistry contract address
+     * @param agentId - On-chain agent ID
+     * @returns ERC-8004 global agent identifier
+     */
+    static buildGlobalAgentId(chainId: number, registryAddress: Address, agentId: number | bigint): GlobalAgentId;
     /**
      * Get the agent's wallet address
      */
@@ -2175,12 +2346,11 @@ declare class ExagentClient {
         raw: `0x${string}`;
     }): Promise<`0x${string}`>;
     private uploadMetadata;
-    private signIntent;
     private parseAgentIdFromReceipt;
 }
 
 /**
- * ExagentVaultFactory ABI
+ * ExagentVaultFactory ABI (Mainnet — no burn fee, seed-based creation)
  */
 declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     readonly type: "function";
@@ -2208,7 +2378,31 @@ declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "minimumVeEXARequired";
+    readonly name: "feeCollector";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "stakingContract";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERIFIED_VEXA_REQUIREMENT";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "MIN_SEED_AMOUNT";
     readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly type: "uint256";
@@ -2216,7 +2410,15 @@ declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     readonly stateMutability: "view";
 }, {
     readonly type: "function";
-    readonly name: "eXABurnFee";
+    readonly name: "UNVERIFIED_CAP_MULTIPLIER";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+}, {
+    readonly type: "function";
+    readonly name: "VERIFIED_CAP_MULTIPLIER";
     readonly inputs: readonly [];
     readonly outputs: readonly [{
         readonly type: "uint256";
@@ -2275,20 +2477,17 @@ declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     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 name: "canCreateVerifiedVault";
+    readonly inputs: readonly [{
+        readonly name: "agentId";
         readonly type: "uint256";
+    }];
+    readonly outputs: readonly [{
+        readonly name: "isVerified";
+        readonly type: "bool";
     }, {
-        readonly name: "stakingContract";
-        readonly type: "address";
-    }, {
-        readonly name: "exaToken";
-        readonly type: "address";
+        readonly name: "reason";
+        readonly type: "string";
     }];
     readonly stateMutability: "view";
 }, {
@@ -2300,6 +2499,9 @@ declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     }, {
         readonly name: "asset";
         readonly type: "address";
+    }, {
+        readonly name: "seedAmount";
+        readonly type: "uint256";
     }, {
         readonly name: "name";
         readonly type: "string";
@@ -2356,15 +2558,14 @@ declare const EXAGENT_VAULT_FACTORY_ABI: readonly [{
     }];
 }];
 /**
- * Vault creation requirements from the factory
+ * Vault creation requirements from the mainnet factory
  */
 interface VaultCreationRequirements {
     veXARequired: bigint;
-    burnFee: bigint;
+    minSeedAmount: bigint;
+    unverifiedCapMultiplier: bigint;
+    verifiedCapMultiplier: bigint;
     stakingContract: Address;
-    exaToken: Address;
-    /** Whether requirements are effectively bypassed (testnet mode) */
-    isBypassed: boolean;
 }
 /**
  * Result of checking if an address can create a vault
@@ -2379,6 +2580,7 @@ interface CanCreateVaultResult {
 interface CreateVaultOptions {
     agentId: bigint;
     asset: Address;
+    seedAmount: bigint;
     name: string;
     symbol: string;
     feeRecipient?: Address;
@@ -2394,7 +2596,7 @@ declare class ExagentVaultFactory {
     private readonly account?;
     constructor(factoryAddress: Address, publicClient: any, walletClient?: any, chain?: Chain, account?: Account);
     /**
-     * Get vault creation requirements
+     * Get vault creation requirements (mainnet: seed-based, no burn fee)
      */
     getRequirements(): Promise<VaultCreationRequirements>;
     /**
@@ -2402,6 +2604,14 @@ declare class ExagentVaultFactory {
      * @param creator Address to check
      */
     canCreateVault(creator: Address): Promise<CanCreateVaultResult>;
+    /**
+     * Check if an agent can create a verified vault (higher deposit cap)
+     * @param agentId Agent ID to check
+     */
+    canCreateVerifiedVault(agentId: bigint): Promise<{
+        isVerified: boolean;
+        reason: string;
+    }>;
     /**
      * Check if an asset is whitelisted for vault creation
      * @param asset Asset address to check
@@ -2426,8 +2636,8 @@ declare class ExagentVaultFactory {
      */
     hasVault(agentId: bigint, asset: Address): Promise<boolean>;
     /**
-     * Create a new vault for an agent
-     * @param options Vault creation options
+     * Create a new vault for an agent (mainnet: requires seed amount)
+     * @param options Vault creation options including seedAmount
      * @returns Transaction hash
      */
     createVault(options: CreateVaultOptions): Promise<Hash>;
@@ -2435,7 +2645,7 @@ declare class ExagentVaultFactory {
      * 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<{
+    checkAndCreateVault(agentId: bigint, asset: Address, seedAmount: bigint, name: string, symbol: string, feeRecipient?: Address): Promise<{
         success: boolean;
         vaultAddress?: Address;
         txHash?: Hash;
@@ -2465,4 +2675,4 @@ declare const TESTNET_ADDRESSES: {
     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 };
+export { type AgentMetadata, type AgentProfile, type StakingInfo$1 as ApiStakingInfo, CHAIN_CONFIG, CONTRACT_ADDRESSES, type CanCreateVaultResult, type CreateVaultOptions, DEX_ADDRESSES, type DepositInfo, EXAGENT_API_CONFIG, EXAGENT_STAKING_ABI, EXAGENT_VAULT_FACTORY_ABI, type EarningsTierInfo, ExagentClient, type ExagentClientConfig, ExagentRegistry, ExagentStaking, ExagentVault, ExagentVaultFactory, type GlobalAgentId, type LockInfo, type NetworkType, type PerformanceSnapshot, type PriceQuote, type RouteQuote, type RouteStep, type RouterTradeResponse, SDK_VERSION, type ServiceRequest, type StakeInfo, type StakingInfo, 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, buildGlobalAgentId, parseGlobalAgentId };