@exagent/sdk 0.1.2 → 0.1.4

package/dist/index.js

@@ -23,7 +23,6 @@ __export(index_exports, {
   CHAIN_CONFIG: () => CHAIN_CONFIG,
   CONTRACT_ADDRESSES: () => CONTRACT_ADDRESSES,
   DEX_ADDRESSES: () => DEX_ADDRESSES,
-  DISCOUNT_TIERS: () => DISCOUNT_TIERS,
   EXAGENT_API_CONFIG: () => EXAGENT_API_CONFIG,
   EXAGENT_STAKING_ABI: () => EXAGENT_STAKING_ABI,
   EXAGENT_VAULT_FACTORY_ABI: () => EXAGENT_VAULT_FACTORY_ABI,
@@ -32,8 +31,11 @@ __export(index_exports, {
   ExagentStaking: () => ExagentStaking,
   ExagentVault: () => ExagentVault,
   ExagentVaultFactory: () => ExagentVaultFactory,
+  SDK_VERSION: () => SDK_VERSION,
   TESTNET_ADDRESSES: () => TESTNET_ADDRESSES,
-  ZERO_X_CONFIG: () => ZERO_X_CONFIG
+  ZERO_X_CONFIG: () => ZERO_X_CONFIG,
+  buildGlobalAgentId: () => buildGlobalAgentId,
+  parseGlobalAgentId: () => parseGlobalAgentId
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -49,7 +51,10 @@ var EXAGENT_REGISTRY_ABI = [
     name: "registerAgent",
     inputs: [
       { name: "name", type: "string" },
-      { name: "metadataURI", type: "string" }
+      { name: "metadataURI", type: "string" },
+      { name: "riskUniverse", type: "uint8" },
+      { name: "maxPositionSizeBps", type: "uint256" },
+      { name: "maxDailyLossBps", type: "uint256" }
     ],
     outputs: [{ name: "agentId", type: "uint256" }],
     stateMutability: "nonpayable"
@@ -279,6 +284,62 @@ var EXAGENT_REGISTRY_ABI = [
     outputs: [{ name: "", type: "bytes32" }],
     stateMutability: "view"
   },
+  // Mainnet: Agent retirement
+  {
+    type: "function",
+    name: "retireAgent",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "retired",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isRetired",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  // Mainnet: Risk universe token whitelists
+  {
+    type: "function",
+    name: "isTradeAllowed",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "token", type: "address" },
+      { name: "aggregator", type: "address" }
+    ],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRiskUniverse",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "uint8" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "tradeCount",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  // Events
+  {
+    type: "event",
+    name: "AgentRetired",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true }
+    ]
+  },
   {
     type: "event",
     name: "ConfigUpdated",
@@ -289,7 +350,16 @@ var EXAGENT_REGISTRY_ABI = [
       { name: "epochId", type: "uint256", indexed: false },
       { name: "blockNumber", type: "uint256", indexed: false }
     ]
-  }
+  },
+  // Custom errors
+  { type: "error", name: "OwnerAlreadyHasAgent", inputs: [{ name: "existingAgentId", type: "uint256" }] },
+  { type: "error", name: "InvalidMetadataURI", inputs: [] },
+  { type: "error", name: "InvalidName", inputs: [] },
+  { type: "error", name: "InvalidRiskUniverse", inputs: [] },
+  { type: "error", name: "InvalidTradingConfig", inputs: [] },
+  { type: "error", name: "NameAlreadyTaken", inputs: [] },
+  { type: "error", name: "AgentNotOwner", inputs: [] },
+  { type: "error", name: "AgentIsRetired", inputs: [] }
 ];
 var ExagentRegistry = class {
   address;
@@ -310,9 +380,12 @@ var ExagentRegistry = class {
    * 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
    */
-  async register(name, metadataURI) {
+  async register(name, metadataURI, riskUniverse = 1, maxPositionSizeBps = 1000n, maxDailyLossBps = 500n) {
     if (!this.walletClient || !this.account) throw new Error("Wallet client and account required for write operations");
     const hash = await this.walletClient.writeContract({
       account: this.account,
@@ -320,7 +393,7 @@ var ExagentRegistry = class {
       address: this.address,
       abi: EXAGENT_REGISTRY_ABI,
       functionName: "registerAgent",
-      args: [name, metadataURI]
+      args: [name, metadataURI, riskUniverse, maxPositionSizeBps, maxDailyLossBps]
     });
     return hash;
   }
@@ -511,19 +584,19 @@ var ExagentRegistry = class {
     return nextId;
   }
   /**
-   * 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, agentId, nonce) {
-    return (0, import_viem.encodePacked)(
+    return (0, import_viem.keccak256)((0, import_viem.encodePacked)(
       ["string", "address", "string", "uint256", "string", "uint256"],
       ["Link wallet ", wallet, " to Exagent ", agentId, " nonce ", nonce]
-    );
+    ));
   }
   // ============ V4: One Agent Per Wallet ============
   /**
@@ -655,8 +728,84 @@ var ExagentRegistry = class {
    * @returns keccak256 hash of the config
    */
   static calculateConfigHash(provider, model) {
-    const { keccak256, encodePacked: encodePacked2 } = require("viem");
-    return keccak256(encodePacked2(["string", "string"], [provider, model]));
+    return (0, import_viem.keccak256)((0, import_viem.encodePacked)(["string", "string"], [provider, model]));
+  }
+  // ============ Agent Retirement ============
+  /**
+   * Retire an agent — marks it as retired, unlinks all wallets, allows new agent registration
+   * @param agentId The agent's ID
+   * @returns Transaction hash
+   */
+  async retireAgent(agentId) {
+    if (!this.walletClient || !this.account) throw new Error("Wallet client and account required for write operations");
+    const hash = await this.walletClient.writeContract({
+      account: this.account,
+      chain: this.chain,
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "retireAgent",
+      args: [agentId]
+    });
+    return hash;
+  }
+  /**
+   * Check if an agent is retired
+   * @param agentId The agent's ID
+   * @returns True if agent is retired
+   */
+  async isRetired(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "isRetired",
+      args: [agentId]
+    });
+    return result;
+  }
+  // ============ Risk Universe Token Eligibility ============
+  /**
+   * 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
+   */
+  async isTradeAllowed(agentId, token, aggregator) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "isTradeAllowed",
+      args: [agentId, token, aggregator]
+    });
+    return result;
+  }
+  /**
+   * 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)
+   */
+  async getRiskUniverse(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getRiskUniverse",
+      args: [agentId]
+    });
+    return Number(result);
+  }
+  /**
+   * Get trade count for an agent
+   * @param agentId The agent's ID
+   * @returns Number of recorded trades
+   */
+  async getTradeCount(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "tradeCount",
+      args: [agentId]
+    });
+    return result;
   }
 };
 
@@ -747,6 +896,9 @@ var ExagentVault = class {
     this.address = vaultAddress;
     this.publicClient = publicClient;
     this.walletClient = walletClient;
+    if (!chain) {
+      throw new Error("Chain parameter is required");
+    }
     this.chain = chain;
     this.account = account;
   }
@@ -1093,17 +1245,34 @@ var ExagentVault = class {
 var EXAGENT_STAKING_ABI = [
   // ============ State Variables ============
   { type: "function", name: "exaToken", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "totalStaked", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "totalDeposited", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "totalLocked", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
   { type: "function", name: "totalVeEXA", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "registry", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "totalEffectiveVeEXA", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
   // ============ Constants ============
   { type: "function", name: "MIN_LOCK_DURATION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
   { type: "function", name: "MAX_LOCK_DURATION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "VAULT_ACCESS_THRESHOLD", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
   { type: "function", name: "PRECISION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  // ============ Staking Functions ============
+  // ============ Phase 1: Deposit / Withdraw ============
+  {
+    type: "function",
+    name: "deposit",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "withdraw",
+    inputs: [{ name: "amount", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  // ============ Phase 2: Lock / Unlock ============
   {
     type: "function",
-    name: "stake",
+    name: "lock",
     inputs: [
       { name: "amount", type: "uint256" },
       { name: "lockDuration", type: "uint256" }
@@ -1111,7 +1280,6 @@ var EXAGENT_STAKING_ABI = [
     outputs: [],
     stateMutability: "nonpayable"
   },
-  { type: "function", name: "unstake", inputs: [], outputs: [], stateMutability: "nonpayable" },
   {
     type: "function",
     name: "extendLock",
@@ -1119,6 +1287,8 @@ var EXAGENT_STAKING_ABI = [
     outputs: [],
     stateMutability: "nonpayable"
   },
+  { type: "function", name: "unlock", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "emergencyWithdraw", inputs: [], outputs: [], stateMutability: "nonpayable" },
   // ============ Reward Functions ============
   { type: "function", name: "claimRewards", inputs: [], outputs: [], stateMutability: "nonpayable" },
   { type: "function", name: "claimRewardsMulti", inputs: [], outputs: [], stateMutability: "nonpayable" },
@@ -1129,26 +1299,17 @@ var EXAGENT_STAKING_ABI = [
     outputs: [],
     stateMutability: "nonpayable"
   },
-  // ============ Delegation Functions ============
-  {
-    type: "function",
-    name: "delegate",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  { type: "function", name: "undelegate", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  // ============ View Functions ============
   {
     type: "function",
-    name: "redelegate",
-    inputs: [{ name: "newAgentId", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
+    name: "depositedAmount",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
   },
-  // ============ View Functions ============
   {
     type: "function",
-    name: "stakes",
+    name: "locks",
     inputs: [{ name: "user", type: "address" }],
     outputs: [
       { name: "amount", type: "uint256" },
@@ -1165,6 +1326,13 @@ var EXAGENT_STAKING_ABI = [
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
   },
+  {
+    type: "function",
+    name: "getEffectiveVeEXA",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
   {
     type: "function",
     name: "calculateVeEXA",
@@ -1194,61 +1362,40 @@ var EXAGENT_STAKING_ABI = [
   },
   {
     type: "function",
-    name: "getDelegatedAgent",
+    name: "getEarningsTier",
     inputs: [{ name: "user", type: "address" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getAgentDelegation",
-    inputs: [{ name: "agentId", type: "uint256" }],
     outputs: [
-      { name: "vexa", type: "uint256" },
-      { name: "count", type: "uint256" }
+      { name: "multiplierBps", type: "uint256" },
+      { name: "tierName", type: "string" }
     ],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "getDiscountTier",
+    name: "getEmergencyWithdrawPenalty",
     inputs: [{ name: "user", type: "address" }],
-    outputs: [{ name: "discountBps", type: "uint256" }],
+    outputs: [{ name: "penaltyBps", type: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "getRewardTokens",
-    inputs: [],
-    outputs: [{ type: "address[]" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "delegatedTo",
+    name: "hasVaultAccess",
     inputs: [{ name: "user", type: "address" }],
-    outputs: [{ type: "uint256" }],
+    outputs: [{ type: "bool" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "userDelegatedVeEXA",
+    name: "getUnlockedBalance",
     inputs: [{ name: "user", type: "address" }],
     outputs: [{ type: "uint256" }],
     stateMutability: "view"
   },
   {
     type: "function",
-    name: "agentDelegatedVeEXA",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "agentDelegatorCount",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "uint256" }],
+    name: "getRewardTokens",
+    inputs: [],
+    outputs: [{ type: "address[]" }],
     stateMutability: "view"
   },
   {
@@ -1261,35 +1408,36 @@ var EXAGENT_STAKING_ABI = [
   // ============ Events ============
   {
     type: "event",
-    name: "Staked",
+    name: "Deposited",
     inputs: [
       { name: "user", type: "address", indexed: true },
       { name: "amount", type: "uint256", indexed: false },
-      { name: "lockDuration", type: "uint256", indexed: false },
-      { name: "unlockTime", type: "uint256", indexed: false },
-      { name: "vEXABalance", type: "uint256", indexed: false }
+      { name: "totalDeposited", type: "uint256", indexed: false }
     ]
   },
   {
     type: "event",
-    name: "Unstaked",
+    name: "Withdrawn",
     inputs: [
       { name: "user", type: "address", indexed: true },
-      { name: "amount", type: "uint256", indexed: false }
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "totalDeposited", type: "uint256", indexed: false }
     ]
   },
   {
     type: "event",
-    name: "LockExtended",
+    name: "Locked",
     inputs: [
       { name: "user", type: "address", indexed: true },
-      { name: "newUnlockTime", type: "uint256", indexed: false },
-      { name: "newVeEXABalance", type: "uint256", indexed: false }
+      { name: "amount", type: "uint256", indexed: false },
+      { name: "lockDuration", type: "uint256", indexed: false },
+      { name: "unlockTime", type: "uint256", indexed: false },
+      { name: "vEXABalance", type: "uint256", indexed: false }
     ]
   },
   {
     type: "event",
-    name: "RewardsClaimed",
+    name: "Unlocked",
     inputs: [
       { name: "user", type: "address", indexed: true },
       { name: "amount", type: "uint256", indexed: false }
@@ -1297,20 +1445,29 @@ var EXAGENT_STAKING_ABI = [
   },
   {
     type: "event",
-    name: "Delegated",
+    name: "EmergencyWithdrawal",
     inputs: [
-      { name: "delegator", type: "address", indexed: true },
-      { name: "agentId", type: "uint256", indexed: true },
-      { name: "veEXAAmount", type: "uint256", indexed: false }
+      { name: "user", type: "address", indexed: true },
+      { name: "returned", type: "uint256", indexed: false },
+      { name: "penalty", type: "uint256", indexed: false },
+      { name: "penaltyBps", type: "uint256", indexed: false }
     ]
   },
   {
     type: "event",
-    name: "Undelegated",
+    name: "LockExtended",
     inputs: [
-      { name: "delegator", type: "address", indexed: true },
-      { name: "agentId", type: "uint256", indexed: true },
-      { name: "veEXAAmount", type: "uint256", indexed: false }
+      { name: "user", type: "address", indexed: true },
+      { name: "newUnlockTime", type: "uint256", indexed: false },
+      { name: "newVeEXABalance", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "RewardsClaimed",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
     ]
   },
   {
@@ -1335,15 +1492,6 @@ var ERC20_APPROVE_ABI2 = [
     stateMutability: "nonpayable"
   }
 ];
-var DISCOUNT_TIERS = {
-  none: 0,
-  bronze: 1e3,
-  // 10% discount at 10,000 vEXA
-  silver: 2500,
-  // 25% discount at 50,000 vEXA
-  gold: 5e3
-  // 50% discount at 100,000 vEXA
-};
 var ExagentStaking = class {
   address;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -1356,108 +1504,119 @@ var ExagentStaking = class {
     this.address = stakingAddress;
     this.publicClient = publicClient;
     this.walletClient = walletClient;
+    if (!chain) {
+      throw new Error("Chain parameter is required");
+    }
     this.chain = chain;
     this.account = account;
   }
-  // ============ Staking Write Functions ============
+  // ============ Phase 1: Deposit / Withdraw ============
   /**
-   * 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'));
    * ```
    */
-  async stake(amount, lockDuration) {
+  async deposit(amount) {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "stake",
-      args: [amount, lockDuration],
+      functionName: "deposit",
+      args: [amount],
       account: this.account,
       chain: this.chain
     });
     return 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
    */
-  async unstake() {
+  async withdraw(amount) {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "unstake",
-      args: [],
+      functionName: "withdraw",
+      args: [amount],
       account: this.account,
       chain: this.chain
     });
     return hash;
   }
+  // ============ Phase 2: Lock / Unlock ============
   /**
-   * Extend lock duration for additional voting power
-   * @param newLockDuration New lock duration in seconds (must be longer than remaining)
+   * 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
+   * );
+   * ```
    */
-  async extendLock(newLockDuration) {
+  async lock(amount, lockDuration) {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "extendLock",
-      args: [newLockDuration],
+      functionName: "lock",
+      args: [amount, lockDuration],
       account: this.account,
       chain: this.chain
     });
     return hash;
   }
-  // ============ Reward Write Functions ============
   /**
-   * Claim accumulated EXA rewards
+   * Extend lock duration for additional voting power
+   * @param newLockDuration New lock duration in seconds (must be longer than remaining)
    * @returns Transaction hash
    */
-  async claimRewards() {
+  async extendLock(newLockDuration) {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "claimRewards",
-      args: [],
+      functionName: "extendLock",
+      args: [newLockDuration],
       account: this.account,
       chain: this.chain
     });
     return hash;
   }
   /**
-   * Claim all pending multi-token rewards (ETH, USDC, etc.)
+   * Unlock EXA after lock expires (normal path — no penalty)
+   * Returns locked amount to unlocked deposited balance.
    * @returns Transaction hash
    */
-  async claimRewardsMulti() {
+  async unlock() {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "claimRewardsMulti",
+      functionName: "unlock",
       args: [],
       account: this.account,
       chain: this.chain
@@ -1465,56 +1624,56 @@ var ExagentStaking = class {
     return hash;
   }
   /**
-   * Claim pending rewards for a specific token
-   * @param token The reward token address to claim
+   * 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
    */
-  async claimRewardsToken(token) {
+  async emergencyWithdraw() {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "claimRewardsToken",
-      args: [token],
+      functionName: "emergencyWithdraw",
+      args: [],
       account: this.account,
       chain: this.chain
     });
     return hash;
   }
-  // ============ Delegation Write Functions ============
+  // ============ Reward Functions ============
   /**
-   * Delegate vEXA voting power to an agent ("Agent Wars")
-   * @param agentId The agent ID to delegate to
+   * Claim accumulated EXA rewards
    * @returns Transaction hash
    */
-  async delegate(agentId) {
+  async claimRewards() {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "delegate",
-      args: [agentId],
+      functionName: "claimRewards",
+      args: [],
       account: this.account,
       chain: this.chain
     });
     return hash;
   }
   /**
-   * Remove delegation from current agent
+   * Claim all pending multi-token rewards (ETH, USDC, etc.)
    * @returns Transaction hash
    */
-  async undelegate() {
+  async claimRewardsMulti() {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "undelegate",
+      functionName: "claimRewardsMulti",
       args: [],
       account: this.account,
       chain: this.chain
@@ -1522,19 +1681,19 @@ var ExagentStaking = class {
     return hash;
   }
   /**
-   * Re-delegate to a different agent (undelegate + delegate in one tx)
-   * @param newAgentId The new agent ID to delegate to
+   * Claim pending rewards for a specific token
+   * @param token The reward token address to claim
    * @returns Transaction hash
    */
-  async redelegate(newAgentId) {
+  async claimRewardsToken(token) {
     if (!this.walletClient || !this.account) {
       throw new Error("Wallet client required for write operations");
     }
     const hash = await this.walletClient.writeContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "redelegate",
-      args: [newAgentId],
+      functionName: "claimRewardsToken",
+      args: [token],
       account: this.account,
       chain: this.chain
     });
@@ -1542,20 +1701,26 @@ var ExagentStaking = class {
   }
   // ============ Read Functions ============
   /**
-   * Get comprehensive staking info for a user
+   * Get comprehensive staking info for a user (deposit + lock)
    * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Staking info with amount, unlock time, and vEXA balance
+   * @returns Combined staking info
    */
-  async getStakeInfo(userAddress) {
+  async getStakingInfo(userAddress) {
     const user = userAddress ?? this.account?.address;
     if (!user) {
       throw new Error("User address required");
     }
-    const [stakeResult, currentVeEXA] = await Promise.all([
+    const [deposited, lockResult, currentVeEXA, vaultAccess, unlockedBalance] = await Promise.all([
       this.publicClient.readContract({
         address: this.address,
         abi: EXAGENT_STAKING_ABI,
-        functionName: "stakes",
+        functionName: "depositedAmount",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "locks",
         args: [user]
       }),
       this.publicClient.readContract({
@@ -1563,20 +1728,88 @@ var ExagentStaking = class {
         abi: EXAGENT_STAKING_ABI,
         functionName: "getVeEXABalance",
         args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "hasVaultAccess",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "getUnlockedBalance",
+        args: [user]
       })
     ]);
-    const stake = stakeResult;
+    const lockData = lockResult;
+    const depositedBigint = deposited;
+    const lockedAmount = lockData[0];
     const now = BigInt(Math.floor(Date.now() / 1e3));
-    const isUnlocked = stake[1] <= now;
-    const remainingLockTime = isUnlocked ? 0n : stake[1] - now;
+    const depositInfo = {
+      deposited: depositedBigint,
+      locked: lockedAmount,
+      unlocked: unlockedBalance,
+      hasVaultAccess: vaultAccess
+    };
+    let lockInfo = null;
+    if (lockedAmount > 0n) {
+      const isUnlocked = lockData[1] <= now;
+      const remainingLockTime = isUnlocked ? 0n : lockData[1] - now;
+      lockInfo = {
+        amount: lockData[0],
+        unlockTime: lockData[1],
+        lockDuration: lockData[2],
+        vEXABalance: lockData[3],
+        currentVeEXA,
+        isUnlocked,
+        remainingLockTime
+      };
+    }
+    return { deposit: depositInfo, lock: lockInfo };
+  }
+  /**
+   * Get deposit info for a user
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Deposit info
+   */
+  async getDepositInfo(userAddress) {
+    const user = userAddress ?? this.account?.address;
+    if (!user) {
+      throw new Error("User address required");
+    }
+    const [deposited, lockResult, vaultAccess, unlockedBalance] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "depositedAmount",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "locks",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "hasVaultAccess",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "getUnlockedBalance",
+        args: [user]
+      })
+    ]);
+    const lockData = lockResult;
     return {
-      amount: stake[0],
-      unlockTime: stake[1],
-      lockDuration: stake[2],
-      vEXABalance: stake[3],
-      currentVeEXA,
-      isUnlocked,
-      remainingLockTime
+      deposited,
+      locked: lockData[0],
+      unlocked: unlockedBalance,
+      hasVaultAccess: vaultAccess
     };
   }
   /**
@@ -1597,11 +1830,28 @@ var ExagentStaking = class {
     });
   }
   /**
-   * 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 Effective vEXA balance
+   */
+  async getEffectiveVeEXA(userAddress) {
+    const user = userAddress ?? this.account?.address;
+    if (!user) {
+      throw new Error("User address required");
+    }
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "getEffectiveVeEXA",
+      args: [user]
+    });
+  }
+  /**
+   * Check if user has vault access (meets deposit threshold)
    * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Agent ID (0 if not delegating)
+   * @returns True if user can access vaults
    */
-  async getDelegatedAgent(userAddress) {
+  async hasVaultAccess(userAddress) {
     const user = userAddress ?? this.account?.address;
     if (!user) {
       throw new Error("User address required");
@@ -1609,52 +1859,47 @@ var ExagentStaking = class {
     return this.publicClient.readContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "getDelegatedAgent",
+      functionName: "hasVaultAccess",
       args: [user]
     });
   }
   /**
-   * Get delegation stats for an agent
-   * @param agentId The agent ID to check
-   * @returns Delegation info with total vEXA and delegator count
+   * Get earnings tier for a user (Bronze/Silver/Gold/Platinum/Diamond)
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Tier info with multiplier and name
    */
-  async getAgentDelegation(agentId) {
+  async getEarningsTier(userAddress) {
+    const user = userAddress ?? this.account?.address;
+    if (!user) {
+      throw new Error("User address required");
+    }
     const result = await this.publicClient.readContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "getAgentDelegation",
-      args: [agentId]
+      functionName: "getEarningsTier",
+      args: [user]
     });
     return {
-      totalVeEXA: result[0],
-      delegatorCount: result[1]
+      multiplierBps: result[0],
+      tierName: result[1]
     };
   }
   /**
-   * Get trading fee discount tier for a user
+   * Get current emergency withdrawal penalty for a user
    * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Discount tier name and basis points
+   * @returns Penalty in basis points (5000 = 50% at lock start, ramps to 2000 over first 25% of lock, then flat 2000)
    */
-  async getDiscountTier(userAddress) {
+  async getEmergencyWithdrawPenalty(userAddress) {
     const user = userAddress ?? this.account?.address;
     if (!user) {
       throw new Error("User address required");
     }
-    const discountBps = await this.publicClient.readContract({
+    return this.publicClient.readContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "getDiscountTier",
+      functionName: "getEmergencyWithdrawPenalty",
       args: [user]
     });
-    let tier = "none";
-    if (discountBps >= 5000n) {
-      tier = "gold";
-    } else if (discountBps >= 2500n) {
-      tier = "silver";
-    } else if (discountBps >= 1000n) {
-      tier = "bronze";
-    }
-    return { tier, discountBps };
   }
   /**
    * Get pending EXA rewards for a user
@@ -1716,14 +1961,25 @@ var ExagentStaking = class {
     });
   }
   /**
-   * 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
    */
-  async getTotalStaked() {
+  async getTotalDeposited() {
     return this.publicClient.readContract({
       address: this.address,
       abi: EXAGENT_STAKING_ABI,
-      functionName: "totalStaked"
+      functionName: "totalDeposited"
+    });
+  }
+  /**
+   * Get total EXA locked across all users
+   * @returns Total locked amount in wei
+   */
+  async getTotalLocked() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "totalLocked"
     });
   }
   /**
@@ -1738,8 +1994,8 @@ var ExagentStaking = class {
     });
   }
   /**
-   * 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
    */
@@ -1764,7 +2020,7 @@ var ExagentStaking = class {
   }
   // ============ Helper Functions ============
   /**
-   * Approve EXA token spending for staking
+   * Approve EXA token spending for deposits
    * @param amount Amount to approve
    * @returns Transaction hash
    */
@@ -1802,25 +2058,28 @@ var ExagentStaking = class {
 
 // src/constants.ts
 var import_chains = require("viem/chains");
+var SDK_VERSION = "0.1.4";
 var CHAIN_CONFIG = {
   mainnet: import_chains.base,
   testnet: import_chains.baseSepolia
 };
 var CONTRACT_ADDRESSES = {
   mainnet: {
-    agentRegistry: "0x0000000000000000000000000000000000000000",
-    // To be deployed
-    exaToken: "0x0000000000000000000000000000000000000000",
-    staking: "0x0000000000000000000000000000000000000000",
-    router: "0x0000000000000000000000000000000000000000",
+    agentRegistry: "0x2261706C751F8ac5cdDb481B7b56EA2137d4A723",
+    exaToken: "0x13403Fb738C97cF7564F279288468c140AaEd05c",
+    staking: "0xAF1729D1519A72f7d9b87aa23a305b775e2849DA",
+    router: "0x11daD5366D903a3eF5d8f07EFF87ce6b173859a9",
     vaultFactory: "0x0000000000000000000000000000000000000000",
-    feeCollector: "0x0000000000000000000000000000000000000000",
+    // Phase 2 — pending deploy
+    feeCollector: "0xe66328a964AF93bEF2eDB226D039C35aE6e66De1",
     buyback: "0x0000000000000000000000000000000000000000",
+    // Phase 2 — pending deploy
     serviceEscrow: "0x0000000000000000000000000000000000000000"
+    // Phase 2 — pending deploy
   },
   testnet: {
     agentRegistry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
-    // V4 UUPS proxy, one-agent-per-wallet
+    // one-agent-per-wallet
     exaToken: "0x66c39b0ad96B3f5eE198Fef913c6636353a48A87",
     staking: "0x439441468e1b1b616E9D36b80969C241F261A011",
     // V2 with delegation
@@ -1850,21 +2109,47 @@ var ZERO_X_CONFIG = {
   // Base
 };
 var EXAGENT_API_CONFIG = {
-  mainnet: "https://api.exagent.io",
-  testnet: "https://api.testnet.exagent.io"
+  mainnet: "https://exagent-api.onrender.com",
+  testnet: "https://exagent-api.onrender.com"
 };
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var PHASE_1_CONTRACTS = /* @__PURE__ */ new Set([
+  "agentRegistry",
+  "exaToken",
+  "staking",
+  "router",
+  "feeCollector"
+]);
 function validateContractAddresses(network) {
   const addresses = CONTRACT_ADDRESSES[network];
-  const zeroEntries = Object.entries(addresses).filter(([, addr]) => addr === ZERO_ADDRESS);
-  if (network === "mainnet" && zeroEntries.length > 0) {
-    const missing = zeroEntries.map(([name]) => name).join(", ");
-    throw new Error(
-      `Mainnet contracts not yet deployed. Missing addresses: ${missing}. Deploy contracts before using the SDK on mainnet.`
-    );
+  if (network === "mainnet") {
+    const missingPhase1 = Object.entries(addresses).filter(([name, addr]) => PHASE_1_CONTRACTS.has(name) && addr === ZERO_ADDRESS).map(([name]) => name);
+    if (missingPhase1.length > 0) {
+      throw new Error(
+        `Mainnet Phase 1 contracts not deployed. Missing: ${missingPhase1.join(", ")}. Update @exagent/sdk to the latest version.`
+      );
+    }
   }
 }
 
+// src/types.ts
+function buildGlobalAgentId(chainId, registryAddress, agentId) {
+  return `eip155:${chainId}:${registryAddress}:${Number(agentId)}`;
+}
+function parseGlobalAgentId(globalId) {
+  const parts = globalId.split(":");
+  if (parts.length !== 4 || parts[0] !== "eip155") {
+    throw new Error(`Invalid ERC-8004 global agent ID: ${globalId}`);
+  }
+  const chainId = parseInt(parts[1], 10);
+  const registryAddress = parts[2];
+  const agentId = parseInt(parts[3], 10);
+  if (isNaN(chainId) || isNaN(agentId)) {
+    throw new Error(`Invalid ERC-8004 global agent ID: ${globalId}`);
+  }
+  return { chainId, registryAddress, agentId };
+}
+
 // src/client.ts
 var ExagentClient = class {
   publicClient;
@@ -1915,6 +2200,14 @@ var ExagentClient = class {
       this.account
     );
   }
+  /** Standard headers for all API requests (includes SDK version for gating) */
+  apiHeaders(contentType) {
+    return {
+      ...contentType && { "Content-Type": contentType },
+      "X-Exagent-SDK-Version": SDK_VERSION,
+      ...this.apiKey && { "X-API-Key": this.apiKey }
+    };
+  }
   // ============ Agent Registration ============
   /**
    * Register as a new agent on Exagent
@@ -1982,14 +2275,14 @@ var ExagentClient = class {
   /**
    * 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 }))
    */
   async linkWallet(wallet, signMessage) {
     const agentId = await this.getAgentId();
     if (!agentId) throw new Error("Agent not registered");
     const nonce = await this.registry.getNonce(wallet);
-    const message = ExagentRegistry.generateLinkMessage(wallet, agentId, nonce);
-    const signature = await signMessage(message);
+    const messageHash = ExagentRegistry.generateLinkMessage(wallet, agentId, nonce);
+    const signature = await signMessage({ raw: messageHash });
     return this.registry.linkWallet(agentId, wallet, signature);
   }
   /**
@@ -2002,127 +2295,15 @@ var ExagentClient = class {
   }
   // ============ Trading ============
   /**
-   * Get optimal DEX route for a trade
-   * Uses 0x API for aggregation across Aerodrome, Uniswap, etc.
-   */
-  async getRoute(intent) {
-    const apiUrl = EXAGENT_API_CONFIG[this.network];
-    const response = await fetch(`${apiUrl}/v1/routes/quote`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
-      body: JSON.stringify({
-        tokenIn: intent.tokenIn,
-        tokenOut: intent.tokenOut,
-        amountIn: intent.amountIn.toString(),
-        slippageBps: intent.maxSlippageBps ?? 50,
-        taker: this.account.address
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: response.statusText }));
-      throw new Error(`Failed to get route: ${error.error}`);
-    }
-    return response.json();
-  }
-  /**
-   * Get price quote without transaction data (faster)
-   */
-  async getPrice(tokenIn, tokenOut, amountIn) {
-    const apiUrl = EXAGENT_API_CONFIG[this.network];
-    const response = await fetch(`${apiUrl}/v1/routes/price`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
-      body: JSON.stringify({
-        tokenIn,
-        tokenOut,
-        amountIn: amountIn.toString()
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: response.statusText }));
-      throw new Error(`Failed to get price: ${error.error}`);
-    }
-    return response.json();
-  }
-  /**
-   * Execute a trade using a pre-fetched route
-   * @param route Route quote from getRoute()
-   * @param options Trade execution options
-   * @returns Transaction hash
-   */
-  async executeTrade(route, options) {
-    if (route.validUntil && Date.now() > route.validUntil) {
-      throw new Error("Quote expired, please fetch a new route");
-    }
-    if (route.issues?.allowance) {
-      throw new Error(
-        `Insufficient allowance for ${route.issues.allowance.spender}. Need ${route.issues.allowance.expected}, have ${route.issues.allowance.actual}`
-      );
-    }
-    if (options?.validateSlippage !== false) {
-      const freshPrice = await this.getPrice(
-        route.tokenIn,
-        route.tokenOut,
-        BigInt(route.amountIn)
-      );
-      const quotedOutput = BigInt(route.amountOut);
-      const freshOutput = BigInt(freshPrice.amountOut);
-      if (freshOutput < quotedOutput * 99n / 100n) {
-        console.warn("Price has moved significantly since quote was fetched");
-      }
-    }
-    const hash = await this.walletClient.sendTransaction({
-      account: this.account,
-      chain: CHAIN_CONFIG[this.network],
-      to: route.transaction.to,
-      data: route.transaction.data,
-      value: BigInt(route.transaction.value)
-    });
-    return hash;
-  }
-  /**
-   * Get and execute a trade in one call
-   * Convenience method that fetches route and executes
-   */
-  async swap(intent) {
-    const route = await this.getRoute(intent);
-    const hash = await this.executeTrade(route);
-    return { hash, route };
-  }
-  /**
-   * Broadcast a trade intent to the network
-   * Other agents can see this and potentially provide better execution
-   */
-  async broadcastIntent(intent) {
-    const agentId = await this.getAgentId();
-    if (!agentId) throw new Error("Agent not registered");
-    const apiUrl = EXAGENT_API_CONFIG[this.network];
-    await fetch(`${apiUrl}/v1/intents`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
-      body: JSON.stringify({
-        agentId: agentId.toString(),
-        intent,
-        signature: await this.signIntent(intent)
-      })
-    });
-  }
-  // ============ Router Trading (Attributed) ============
-  /**
-   * Execute a trade through ExagentRouter for full attribution
+   * Execute a trade through ExagentRouter
    *
-   * 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.
+   * 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
+   *
+   * There is no way to trade outside the router. This is by design.
    *
    * @param intent Trade parameters
    * @returns Trade result with transaction hash
@@ -2175,10 +2356,7 @@ var ExagentClient = class {
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const response = await fetch(`${apiUrl}/v1/router/trade`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
+      headers: this.apiHeaders("application/json"),
       body: JSON.stringify({
         agentId: id.toString(),
         tokenIn: intent.tokenIn,
@@ -2227,10 +2405,7 @@ var ExagentClient = class {
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const response = await fetch(`${apiUrl}/v1/services/request`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
+      headers: this.apiHeaders("application/json"),
       body: JSON.stringify({
         requesterId: agentId.toString(),
         ...request
@@ -2248,7 +2423,9 @@ var ExagentClient = class {
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const params = new URLSearchParams();
     if (serviceType) params.set("type", serviceType);
-    const response = await fetch(`${apiUrl}/v1/services?${params}`);
+    const response = await fetch(`${apiUrl}/v1/services?${params}`, {
+      headers: this.apiHeaders()
+    });
     return response.json();
   }
   // ============ Leaderboards ============
@@ -2261,7 +2438,9 @@ var ExagentClient = class {
     if (options?.category) params.set("category", options.category);
     if (options?.limit) params.set("limit", options.limit.toString());
     if (options?.offset) params.set("offset", options.offset.toString());
-    const response = await fetch(`${apiUrl}/v1/rankings/leaderboard?${params}`);
+    const response = await fetch(`${apiUrl}/v1/rankings/leaderboard?${params}`, {
+      headers: this.apiHeaders()
+    });
     return response.json();
   }
   // ============ Vault Functions (Phase 4: Copy Trading) ============
@@ -2289,9 +2468,7 @@ var ExagentClient = class {
     if (!id) throw new Error("Agent not registered");
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const response = await fetch(`${apiUrl}/v1/vaults?agentId=${id}`, {
-      headers: {
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      }
+      headers: this.apiHeaders()
     });
     if (!response.ok) {
       throw new Error(`Failed to get vaults: ${response.statusText}`);
@@ -2307,9 +2484,7 @@ var ExagentClient = class {
     const user = userAddress ?? this.account.address;
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const response = await fetch(`${apiUrl}/v1/vaults?depositor=${user}`, {
-      headers: {
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      }
+      headers: this.apiHeaders()
     });
     if (!response.ok) {
       throw new Error(`Failed to get user vaults: ${response.statusText}`);
@@ -2329,9 +2504,7 @@ var ExagentClient = class {
     if (options?.period) params.set("period", options.period);
     if (options?.limit) params.set("limit", options.limit.toString());
     const response = await fetch(`${apiUrl}/v1/vaults/top?${params}`, {
-      headers: {
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      }
+      headers: this.apiHeaders()
     });
     if (!response.ok) {
       throw new Error(`Failed to get top vaults: ${response.statusText}`);
@@ -2372,37 +2545,73 @@ var ExagentClient = class {
   }
   // ============ Staking Functions ============
   /**
-   * 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'));
+   * ```
+   */
+  async depositExa(amount) {
+    await this.staking.approveExa(amount);
+    return this.staking.deposit(amount);
+  }
+  /**
+   * Withdraw unlocked EXA tokens (instant, no penalty)
+   * @param amount Amount of EXA to withdraw (in wei)
+   * @returns Transaction hash
+   */
+  async withdrawExa(amount) {
+    return this.staking.withdraw(amount);
+  }
+  /**
+   * 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
    * );
    * ```
    */
-  async stakeExa(amount, lockDuration) {
-    await this.staking.approveExa(amount);
-    return this.staking.stake(amount, lockDuration);
+  async lockExa(amount, lockDuration) {
+    return this.staking.lock(amount, lockDuration);
+  }
+  /**
+   * Unlock EXA after lock expires (no penalty)
+   * @returns Transaction hash
+   */
+  async unlockExa() {
+    return this.staking.unlock();
   }
   /**
-   * Unstake EXA tokens after lock expires
+   * Emergency withdrawal from active lock (graduated 50%→20% penalty)
    * @returns Transaction hash
    */
-  async unstakeExa() {
-    return this.staking.unstake();
+  async emergencyWithdrawExa() {
+    return this.staking.emergencyWithdraw();
   }
   /**
-   * Get staking info for the connected wallet
-   * @returns Staking info including amount, unlock time, and vEXA balance
+   * Get comprehensive staking info (deposit + lock) for the connected wallet
+   * @returns Staking info including deposit status and lock status
    */
   async getStakingInfo() {
-    return this.staking.getStakeInfo();
+    return this.staking.getStakingInfo();
+  }
+  /**
+   * Get deposit info for the connected wallet
+   * @returns Deposit info (deposited, locked, unlocked, vault access)
+   */
+  async getDepositInfo() {
+    return this.staking.getDepositInfo();
   }
   /**
    * Get current vEXA balance for the connected wallet
@@ -2412,20 +2621,25 @@ var ExagentClient = class {
     return this.staking.getVeEXABalance();
   }
   /**
-   * 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
    */
-  async delegateToAgent(agentId) {
-    return this.staking.delegate(agentId);
+  async hasVaultAccess() {
+    return this.staking.hasVaultAccess();
   }
   /**
-   * Get delegation stats for an agent
-   * @param agentId The agent ID to check
-   * @returns Delegation info with total vEXA and delegator count
+   * Get earnings tier for the connected wallet
+   * @returns Tier info with multiplier and name
    */
-  async getAgentDelegation(agentId) {
-    return this.staking.getAgentDelegation(agentId);
+  async getEarningsTier() {
+    return this.staking.getEarningsTier();
+  }
+  /**
+   * Get emergency withdrawal penalty for the connected wallet
+   * @returns Penalty in basis points (5000 = 50% at start, 2000 = 20% near expiry)
+   */
+  async getEmergencyWithdrawPenalty() {
+    return this.staking.getEmergencyWithdrawPenalty();
   }
   /**
    * Claim all pending staking rewards (EXA + multi-token)
@@ -2436,6 +2650,46 @@ var ExagentClient = class {
     const multiTokenRewards = await this.staking.claimRewardsMulti();
     return { exaRewards, multiTokenRewards };
   }
+  // ============ ERC-8004 Global Agent Identity ============
+  /**
+   * 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"
+   * ```
+   */
+  async getGlobalAgentId() {
+    const agentId = await this.getAgentId();
+    if (!agentId) throw new Error("Agent not registered");
+    const chain = CHAIN_CONFIG[this.network];
+    const addresses = CONTRACT_ADDRESSES[this.network];
+    return buildGlobalAgentId(
+      chain.id,
+      addresses.agentRegistry,
+      agentId
+    );
+  }
+  /**
+   * 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, registryAddress, agentId) {
+    return buildGlobalAgentId(chainId, registryAddress, agentId);
+  }
   // ============ Helpers ============
   /**
    * Get the agent's wallet address
@@ -2455,10 +2709,7 @@ var ExagentClient = class {
     const apiUrl = EXAGENT_API_CONFIG[this.network];
     const response = await fetch(`${apiUrl}/v1/metadata/upload`, {
       method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.apiKey && { "X-API-Key": this.apiKey }
-      },
+      headers: this.apiHeaders("application/json"),
       body: JSON.stringify(metadata)
     });
     if (!response.ok) {
@@ -2467,12 +2718,16 @@ var ExagentClient = class {
     const result = await response.json();
     return result.uri;
   }
-  async signIntent(intent) {
-    const message = JSON.stringify(intent);
-    return this.walletClient.signMessage({ account: this.account, message });
-  }
   parseAgentIdFromReceipt(receipt) {
-    return 1n;
+    const registryAddress = this.registry.address.toLowerCase();
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== registryAddress) continue;
+      if (log.topics.length >= 2 && log.topics[1]) {
+        const agentId = BigInt(log.topics[1]);
+        return agentId;
+      }
+    }
+    throw new Error("AgentRegistered event not found in transaction receipt");
   }
 };
 
@@ -2482,8 +2737,12 @@ var EXAGENT_VAULT_FACTORY_ABI = [
   { type: "function", name: "owner", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
   { type: "function", name: "registry", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
   { type: "function", name: "router", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "minimumVeEXARequired", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "eXABurnFee", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "feeCollector", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "stakingContract", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "VERIFIED_VEXA_REQUIREMENT", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "MIN_SEED_AMOUNT", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "UNVERIFIED_CAP_MULTIPLIER", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "VERIFIED_CAP_MULTIPLIER", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
   { type: "function", name: "allowedAssets", inputs: [{ name: "asset", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" },
   { type: "function", name: "vaults", inputs: [{ name: "agentId", type: "uint256" }, { name: "asset", type: "address" }], outputs: [{ type: "address" }], stateMutability: "view" },
   { type: "function", name: "agentVaultCount", inputs: [{ name: "agentId", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
@@ -2496,14 +2755,9 @@ var EXAGENT_VAULT_FACTORY_ABI = [
   },
   {
     type: "function",
-    name: "getVaultCreationRequirements",
-    inputs: [],
-    outputs: [
-      { name: "veXARequired", type: "uint256" },
-      { name: "burnFee", type: "uint256" },
-      { name: "stakingContract", type: "address" },
-      { name: "exaToken", type: "address" }
-    ],
+    name: "canCreateVerifiedVault",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "isVerified", type: "bool" }, { name: "reason", type: "string" }],
     stateMutability: "view"
   },
   // Write functions
@@ -2513,6 +2767,7 @@ var EXAGENT_VAULT_FACTORY_ABI = [
     inputs: [
       { name: "agentId", type: "uint256" },
       { name: "asset", type: "address" },
+      { name: "seedAmount", type: "uint256" },
       { name: "name", type: "string" },
       { name: "symbol", type: "string" },
       { name: "feeRecipient", type: "address" }
@@ -2554,50 +2809,51 @@ var ExagentVaultFactory = class {
     this.address = factoryAddress;
     this.publicClient = publicClient;
     this.walletClient = walletClient;
+    if (!chain) {
+      throw new Error("Chain parameter is required");
+    }
     this.chain = chain;
     this.account = account;
   }
   // ============ Read Functions ============
   /**
-   * Get vault creation requirements
+   * Get vault creation requirements (mainnet: seed-based, no burn fee)
    */
   async getRequirements() {
-    try {
-      const result = await this.publicClient.readContract({
+    const [veXARequired, minSeedAmount, unverifiedCapMultiplier, verifiedCapMultiplier, stakingContract] = await Promise.all([
+      this.publicClient.readContract({
         address: this.address,
         abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "getVaultCreationRequirements"
-      });
-      const isBypassed = result[0] === BigInt(0) && result[1] === BigInt(0) && (result[2] === "0x0000000000000000000000000000000000000000" || result[3] === "0x0000000000000000000000000000000000000000");
-      return {
-        veXARequired: result[0],
-        burnFee: result[1],
-        stakingContract: result[2],
-        exaToken: result[3],
-        isBypassed
-      };
-    } catch {
-      const [veXARequired, burnFee] = await Promise.all([
-        this.publicClient.readContract({
-          address: this.address,
-          abi: EXAGENT_VAULT_FACTORY_ABI,
-          functionName: "minimumVeEXARequired"
-        }),
-        this.publicClient.readContract({
-          address: this.address,
-          abi: EXAGENT_VAULT_FACTORY_ABI,
-          functionName: "eXABurnFee"
-        })
-      ]);
-      const isBypassed = veXARequired === BigInt(0) && burnFee === BigInt(0);
-      return {
-        veXARequired,
-        burnFee,
-        stakingContract: "0x0000000000000000000000000000000000000000",
-        exaToken: "0x0000000000000000000000000000000000000000",
-        isBypassed
-      };
-    }
+        functionName: "VERIFIED_VEXA_REQUIREMENT"
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_VAULT_FACTORY_ABI,
+        functionName: "MIN_SEED_AMOUNT"
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_VAULT_FACTORY_ABI,
+        functionName: "UNVERIFIED_CAP_MULTIPLIER"
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_VAULT_FACTORY_ABI,
+        functionName: "VERIFIED_CAP_MULTIPLIER"
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_VAULT_FACTORY_ABI,
+        functionName: "stakingContract"
+      })
+    ]);
+    return {
+      veXARequired,
+      minSeedAmount,
+      unverifiedCapMultiplier,
+      verifiedCapMultiplier,
+      stakingContract
+    };
   }
   /**
    * Check if an address can create a vault
@@ -2615,6 +2871,22 @@ var ExagentVaultFactory = class {
       reason: result[1]
     };
   }
+  /**
+   * Check if an agent can create a verified vault (higher deposit cap)
+   * @param agentId Agent ID to check
+   */
+  async canCreateVerifiedVault(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "canCreateVerifiedVault",
+      args: [agentId]
+    });
+    return {
+      isVerified: result[0],
+      reason: result[1]
+    };
+  }
   /**
    * Check if an asset is whitelisted for vault creation
    * @param asset Asset address to check
@@ -2664,8 +2936,8 @@ var ExagentVaultFactory = class {
   }
   // ============ Write Functions ============
   /**
-   * 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
    */
   async createVault(options) {
@@ -2677,7 +2949,7 @@ var ExagentVaultFactory = class {
       address: this.address,
       abi: EXAGENT_VAULT_FACTORY_ABI,
       functionName: "createVault",
-      args: [options.agentId, options.asset, options.name, options.symbol, feeRecipient],
+      args: [options.agentId, options.asset, options.seedAmount, options.name, options.symbol, feeRecipient],
       account: this.account,
       chain: this.chain
     });
@@ -2688,7 +2960,7 @@ var ExagentVaultFactory = class {
    * Check all requirements and create a vault if possible
    * Returns detailed status about each requirement
    */
-  async checkAndCreateVault(agentId, asset, name, symbol, feeRecipient) {
+  async checkAndCreateVault(agentId, asset, seedAmount, name, symbol, feeRecipient) {
     const [canCreateResult, assetAllowed, hasExisting] = await Promise.all([
       this.canCreateVault(this.account?.address ?? "0x0000000000000000000000000000000000000000"),
       this.isAssetAllowed(asset),
@@ -2727,6 +2999,7 @@ var ExagentVaultFactory = class {
       const txHash = await this.createVault({
         agentId,
         asset,
+        seedAmount,
         name,
         symbol,
         feeRecipient
@@ -2760,7 +3033,6 @@ var ExagentVaultFactory = class {
 // src/index.ts
 var TESTNET_ADDRESSES = {
   registry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
-  // V4 UUPS proxy
   token: "0x66c39b0ad96B3f5eE198Fef913c6636353a48A87",
   staking: "0x439441468e1b1b616E9D36b80969C241F261A011",
   router: "0xc0c27eEE047E414CD716D06C2444CF2073113d5C",
@@ -2777,7 +3049,6 @@ var TESTNET_ADDRESSES = {
   CHAIN_CONFIG,
   CONTRACT_ADDRESSES,
   DEX_ADDRESSES,
-  DISCOUNT_TIERS,
   EXAGENT_API_CONFIG,
   EXAGENT_STAKING_ABI,
   EXAGENT_VAULT_FACTORY_ABI,
@@ -2786,6 +3057,9 @@ var TESTNET_ADDRESSES = {
   ExagentStaking,
   ExagentVault,
   ExagentVaultFactory,
+  SDK_VERSION,
   TESTNET_ADDRESSES,
-  ZERO_X_CONFIG
+  ZERO_X_CONFIG,
+  buildGlobalAgentId,
+  parseGlobalAgentId
 });