@exagent/sdk 0.1.0

package/dist/index.mjs

@@ -0,0 +1,2738 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/client.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+
+// src/contracts/registry.ts
+var EXAGENT_REGISTRY_ABI = [
+  {
+    type: "function",
+    name: "registerAgent",
+    inputs: [
+      { name: "name", type: "string" },
+      { name: "metadataURI", type: "string" }
+    ],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "isNameAvailable",
+    inputs: [{ name: "name", type: "string" }],
+    outputs: [{ name: "available", type: "bool" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentByName",
+    inputs: [{ name: "name", type: "string" }],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "linkWallet",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "wallet", type: "address" },
+      { name: "signature", type: "bytes" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "linkOwnWallet",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "unlinkWallet",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "wallet", type: "address" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "updateMetadata",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newURI", type: "string" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "agents",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [
+      { name: "owner", type: "address" },
+      { name: "name", type: "string" },
+      { name: "metadataURI", type: "string" },
+      { name: "registrationTime", type: "uint256" },
+      { name: "verified", type: "bool" },
+      { name: "linkedWalletCount", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getLinkedWallets",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentForWallet",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "walletToAgent",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "nonces",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "nextAgentId",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "ownerOf",
+    inputs: [{ name: "tokenId", type: "uint256" }],
+    outputs: [{ name: "", type: "address" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "AgentRegistered",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "owner", type: "address", indexed: true },
+      { name: "name", type: "string", indexed: false },
+      { name: "metadataURI", type: "string", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "WalletLinked",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "wallet", type: "address", indexed: true }
+    ]
+  },
+  {
+    type: "event",
+    name: "WalletUnlinked",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "wallet", type: "address", indexed: true }
+    ]
+  },
+  // V4: One agent per wallet
+  {
+    type: "function",
+    name: "ownerToAgentId",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentByOwner",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [{ name: "agentId", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "canWalletRegister",
+    inputs: [{ name: "wallet", type: "address" }],
+    outputs: [
+      { name: "canRegister", type: "bool" },
+      { name: "existingAgentId", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "version",
+    inputs: [],
+    outputs: [{ name: "", type: "string" }],
+    stateMutability: "pure"
+  },
+  // Config Epochs
+  {
+    type: "function",
+    name: "updateConfig",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "newConfigHash", type: "bytes32" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "getConfigHash",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getCurrentEpoch",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getAgentConfig",
+    inputs: [{ name: "agentId", type: "uint256" }],
+    outputs: [
+      {
+        name: "",
+        type: "tuple",
+        components: [
+          { name: "configHash", type: "bytes32" },
+          { name: "epochId", type: "uint256" },
+          { name: "epochStartBlock", type: "uint256" }
+        ]
+      }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getEpochConfigHash",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "epochId", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bytes32" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "ConfigUpdated",
+    inputs: [
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "oldConfigHash", type: "bytes32", indexed: false },
+      { name: "newConfigHash", type: "bytes32", indexed: false },
+      { name: "epochId", type: "uint256", indexed: false },
+      { name: "blockNumber", type: "uint256", indexed: false }
+    ]
+  }
+];
+var ExagentRegistry = class {
+  address;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  chain;
+  account;
+  constructor(address, publicClient, walletClient, chain, account) {
+    this.address = address;
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.chain = chain;
+    this.account = account;
+  }
+  /**
+   * Register a new agent
+   * @param name Unique agent name (3-32 chars, alphanumeric + spaces/hyphens/underscores)
+   * @param metadataURI IPFS URI for agent metadata
+   * @returns Transaction hash
+   */
+  async register(name, metadataURI) {
+    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: "registerAgent",
+      args: [name, metadataURI]
+    });
+    return hash;
+  }
+  /**
+   * Check if a name is available for registration
+   * @param name The name to check
+   * @returns True if the name can be used
+   */
+  async isNameAvailable(name) {
+    const available = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "isNameAvailable",
+      args: [name]
+    });
+    return available;
+  }
+  /**
+   * Get the agent ID that owns a specific name
+   * @param name The name to look up
+   * @returns Agent ID (0 if not taken)
+   */
+  async getAgentByName(name) {
+    const agentId = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getAgentByName",
+      args: [name]
+    });
+    return agentId;
+  }
+  /**
+   * Link the wallet used by the agent to their agent ID
+   * @param agentId The agent's ID
+   * @returns Transaction hash
+   */
+  async linkOwnWallet(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: "linkOwnWallet",
+      args: [agentId]
+    });
+    return hash;
+  }
+  /**
+   * Link an external wallet with signature proof
+   * @param agentId The agent's ID
+   * @param wallet The wallet to link
+   * @param signature Signature from the wallet proving ownership
+   * @returns Transaction hash
+   */
+  async linkWallet(agentId, wallet, signature) {
+    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: "linkWallet",
+      args: [agentId, wallet, signature]
+    });
+    return hash;
+  }
+  /**
+   * Unlink a wallet from an agent
+   * @param agentId The agent's ID
+   * @param wallet The wallet to unlink
+   * @returns Transaction hash
+   */
+  async unlinkWallet(agentId, wallet) {
+    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: "unlinkWallet",
+      args: [agentId, wallet]
+    });
+    return hash;
+  }
+  /**
+   * Update agent metadata
+   * @param agentId The agent's ID
+   * @param newURI New IPFS URI for metadata
+   * @returns Transaction hash
+   */
+  async updateMetadata(agentId, newURI) {
+    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: "updateMetadata",
+      args: [agentId, newURI]
+    });
+    return hash;
+  }
+  /**
+   * Get agent profile by ID
+   * @param agentId The agent's ID
+   * @returns Agent profile data
+   */
+  async getAgent(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "agents",
+      args: [agentId]
+    });
+    return {
+      agentId,
+      owner: result[0],
+      name: result[1],
+      metadataURI: result[2],
+      registrationTime: result[3],
+      verified: result[4],
+      linkedWalletCount: result[5]
+    };
+  }
+  /**
+   * Get all linked wallets for an agent
+   * @param agentId The agent's ID
+   * @returns Array of linked wallet addresses
+   */
+  async getLinkedWallets(agentId) {
+    const wallets = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getLinkedWallets",
+      args: [agentId]
+    });
+    return wallets;
+  }
+  /**
+   * Get agent ID for a wallet (for trade attribution)
+   * @param wallet The wallet address
+   * @returns Agent ID (0 if not linked)
+   */
+  async getAgentForWallet(wallet) {
+    const agentId = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "walletToAgent",
+      args: [wallet]
+    });
+    return agentId;
+  }
+  /**
+   * Check if a wallet is linked to a specific agent
+   * @param agentId The agent's ID
+   * @param wallet The wallet address to check
+   * @returns True if the wallet is linked to the agent
+   */
+  async isLinkedWallet(agentId, wallet) {
+    const linkedWallets = await this.getLinkedWallets(agentId);
+    return linkedWallets.some((w) => w.toLowerCase() === wallet.toLowerCase());
+  }
+  /**
+   * Get the nonce for wallet linking signature
+   * @param wallet The wallet address
+   * @returns Current nonce
+   */
+  async getNonce(wallet) {
+    const nonce = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "nonces",
+      args: [wallet]
+    });
+    return nonce;
+  }
+  /**
+   * Get the next agent ID that will be assigned
+   * @returns Next agent ID
+   */
+  async getNextAgentId() {
+    const nextId = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "nextAgentId"
+    });
+    return nextId;
+  }
+  /**
+   * Generate the message to sign for wallet linking
+   * @param wallet The wallet to link
+   * @param agentId The agent ID to link to
+   * @param nonce The current nonce for the wallet
+   * @returns Message to sign
+   */
+  static generateLinkMessage(wallet, agentId, nonce) {
+    return `Link wallet ${wallet} to Exagent ${agentId} nonce ${nonce}`;
+  }
+  // ============ V4: One Agent Per Wallet ============
+  /**
+   * Get the agent owned by a wallet (not linked, owned)
+   * @param wallet The wallet to look up
+   * @returns Agent ID (0 if wallet doesn't own an agent)
+   */
+  async getAgentByOwner(wallet) {
+    const agentId = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getAgentByOwner",
+      args: [wallet]
+    });
+    return agentId;
+  }
+  /**
+   * Check if a wallet can register a new agent
+   * @param wallet The wallet to check
+   * @returns Object with canRegister boolean and existingAgentId (0 if none)
+   */
+  async canWalletRegister(wallet) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "canWalletRegister",
+      args: [wallet]
+    });
+    const [canRegister, existingAgentId] = result;
+    return { canRegister, existingAgentId };
+  }
+  /**
+   * Get the registry contract version
+   * @returns Version string (e.g., "4.0.0")
+   */
+  async getVersion() {
+    const version = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "version"
+    });
+    return version;
+  }
+  // ============ Config Epochs ============
+  /**
+   * Update the agent's LLM config hash on-chain
+   * @param agentId The agent's ID
+   * @param configHash The keccak256 hash of (provider, model)
+   * @returns Transaction hash
+   */
+  async updateConfig(agentId, configHash) {
+    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: "updateConfig",
+      args: [agentId, configHash]
+    });
+    return hash;
+  }
+  /**
+   * Get the current config hash for an agent
+   * @param agentId The agent's ID
+   * @returns Config hash (bytes32(0) if never set)
+   */
+  async getConfigHash(agentId) {
+    const configHash = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getConfigHash",
+      args: [agentId]
+    });
+    return configHash;
+  }
+  /**
+   * Get the current epoch ID for an agent
+   * @param agentId The agent's ID
+   * @returns Current epoch (0 if never configured)
+   */
+  async getCurrentEpoch(agentId) {
+    const epochId = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getCurrentEpoch",
+      args: [agentId]
+    });
+    return epochId;
+  }
+  /**
+   * Get full config info for an agent
+   * @param agentId The agent's ID
+   * @returns AgentConfig struct (configHash, epochId, epochStartBlock)
+   */
+  async getAgentConfig(agentId) {
+    const config = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getAgentConfig",
+      args: [agentId]
+    });
+    const result = config;
+    return {
+      configHash: result.configHash,
+      epochId: result.epochId,
+      epochStartBlock: result.epochStartBlock
+    };
+  }
+  /**
+   * Get the config hash for a specific epoch
+   * @param agentId The agent's ID
+   * @param epochId The epoch to look up
+   * @returns Config hash for that epoch
+   */
+  async getEpochConfigHash(agentId, epochId) {
+    const configHash = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_REGISTRY_ABI,
+      functionName: "getEpochConfigHash",
+      args: [agentId, epochId]
+    });
+    return configHash;
+  }
+  /**
+   * Calculate the config hash for a provider and model
+   * @param provider The LLM provider name (e.g., "openai", "anthropic")
+   * @param model The model name (e.g., "gpt-4", "claude-opus-4.5")
+   * @returns keccak256 hash of the config
+   */
+  static calculateConfigHash(provider, model) {
+    const { keccak256, encodePacked } = __require("viem");
+    return keccak256(encodePacked(["string", "string"], [provider, model]));
+  }
+};
+
+// src/contracts/vault.ts
+var EXAGENT_VAULT_ABI = [
+  // ERC-4626 Standard
+  { type: "function", name: "asset", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "totalAssets", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "convertToShares", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "convertToAssets", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxDeposit", inputs: [{ name: "receiver", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxMint", inputs: [{ name: "receiver", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxWithdraw", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "maxRedeem", inputs: [{ name: "owner", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewDeposit", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewMint", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewWithdraw", inputs: [{ name: "assets", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "previewRedeem", inputs: [{ name: "shares", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "deposit", inputs: [{ name: "assets", type: "uint256" }, { name: "receiver", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "mint", inputs: [{ name: "shares", type: "uint256" }, { name: "receiver", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "withdraw", inputs: [{ name: "assets", type: "uint256" }, { name: "receiver", type: "address" }, { name: "owner", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "redeem", inputs: [{ name: "shares", type: "uint256" }, { name: "receiver", type: "address" }, { name: "owner", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  // ERC-20
+  { type: "function", name: "name", inputs: [], outputs: [{ type: "string" }], stateMutability: "view" },
+  { type: "function", name: "symbol", inputs: [], outputs: [{ type: "string" }], stateMutability: "view" },
+  { type: "function", name: "decimals", inputs: [], outputs: [{ type: "uint8" }], stateMutability: "view" },
+  { type: "function", name: "totalSupply", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "balanceOf", inputs: [{ name: "account", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "allowance", inputs: [{ name: "owner", type: "address" }, { name: "spender", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "approve", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" },
+  // Custom Exagent Vault
+  { type: "function", name: "agentId", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "sharePrice", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "effectiveShares", inputs: [{ name: "user", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "userHighWaterMark", inputs: [{ name: "user", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "performanceFeeBps", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "managementFeeBps", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "feeRecipient", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
+  { type: "function", name: "highWaterMark", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "depositsPaused", inputs: [], outputs: [{ type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "withdrawalsPaused", inputs: [], outputs: [{ type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "circuitBreakerActive", inputs: [], outputs: [{ type: "bool" }], stateMutability: "view" },
+  { type: "function", name: "pendingWithdrawals", inputs: [{ name: "user", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "canWithdraw", inputs: [{ name: "user", type: "address" }], outputs: [{ type: "bool" }, { type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "getRateLimitStatus", inputs: [], outputs: [{ name: "remaining", type: "uint256" }, { name: "periodEnds", type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "getWithdrawalQueueLength", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  // Withdrawal Queue
+  { type: "function", name: "requestWithdrawal", inputs: [{ name: "shares", type: "uint256" }, { name: "receiver", type: "address" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "claimWithdrawal", inputs: [{ name: "requestId", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "nonpayable" },
+  { type: "function", name: "cancelWithdrawal", inputs: [{ name: "requestId", type: "uint256" }], outputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "getPendingWithdrawal",
+    inputs: [{ name: "requestId", type: "uint256" }],
+    outputs: [
+      { name: "owner", type: "address" },
+      { name: "receiver", type: "address" },
+      { name: "shares", type: "uint256" },
+      { name: "requestTime", type: "uint256" },
+      { name: "processed", type: "bool" },
+      { name: "claimableAt", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  // Emergency
+  { type: "function", name: "emergencyWithdraw", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  // Events
+  { type: "event", name: "Deposit", inputs: [{ name: "sender", type: "address", indexed: true }, { name: "owner", type: "address", indexed: true }, { name: "assets", type: "uint256" }, { name: "shares", type: "uint256" }] },
+  { type: "event", name: "Withdraw", inputs: [{ name: "sender", type: "address", indexed: true }, { name: "receiver", type: "address", indexed: true }, { name: "owner", type: "address", indexed: true }, { name: "assets", type: "uint256" }, { name: "shares", type: "uint256" }] },
+  { type: "event", name: "PerformanceFeeCharged", inputs: [{ name: "user", type: "address", indexed: true }, { name: "feeShares", type: "uint256" }, { name: "profit", type: "uint256" }] },
+  { type: "event", name: "WithdrawalRequested", inputs: [{ name: "requestId", type: "uint256", indexed: true }, { name: "owner", type: "address", indexed: true }, { name: "shares", type: "uint256" }, { name: "timestamp", type: "uint256" }] },
+  { type: "event", name: "WithdrawalClaimed", inputs: [{ name: "requestId", type: "uint256", indexed: true }, { name: "receiver", type: "address", indexed: true }, { name: "assets", type: "uint256" }] },
+  { type: "event", name: "WithdrawalCancelled", inputs: [{ name: "requestId", type: "uint256", indexed: true }] },
+  { type: "event", name: "EmergencyWithdrawal", inputs: [{ name: "user", type: "address", indexed: true }, { name: "shares", type: "uint256" }, { name: "assets", type: "uint256" }] }
+];
+var ERC20_APPROVE_ABI = [
+  { type: "function", name: "approve", inputs: [{ name: "spender", type: "address" }, { name: "amount", type: "uint256" }], outputs: [{ type: "bool" }], stateMutability: "nonpayable" }
+];
+var ExagentVault = class {
+  address;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  chain;
+  account;
+  constructor(vaultAddress, publicClient, walletClient, chain, account) {
+    this.address = vaultAddress;
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.chain = chain;
+    this.account = account;
+  }
+  // ============ Read Functions ============
+  /**
+   * Get comprehensive vault info
+   */
+  async getVaultInfo() {
+    const [
+      name,
+      symbol,
+      asset,
+      agentId,
+      totalAssets,
+      totalSupply,
+      sharePrice,
+      highWaterMark,
+      performanceFeeBps,
+      managementFeeBps,
+      feeRecipient,
+      depositsPaused,
+      withdrawalsPaused,
+      circuitBreakerActive
+    ] = await Promise.all([
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "name" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "symbol" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "asset" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "agentId" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "totalAssets" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "totalSupply" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "sharePrice" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "highWaterMark" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "performanceFeeBps" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "managementFeeBps" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "feeRecipient" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "depositsPaused" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "withdrawalsPaused" }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "circuitBreakerActive" })
+    ]);
+    return {
+      address: this.address,
+      name,
+      symbol,
+      asset,
+      agentId,
+      totalAssets,
+      totalSupply,
+      sharePrice,
+      highWaterMark,
+      performanceFeeBps,
+      managementFeeBps,
+      feeRecipient,
+      depositsPaused,
+      withdrawalsPaused,
+      circuitBreakerActive
+    };
+  }
+  /**
+   * Get user's position in the vault
+   */
+  async getPosition(user) {
+    const [
+      shares,
+      effectiveShares,
+      pendingWithdrawals,
+      userHighWaterMark,
+      canWithdrawResult
+    ] = await Promise.all([
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "balanceOf", args: [user] }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "effectiveShares", args: [user] }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "pendingWithdrawals", args: [user] }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "userHighWaterMark", args: [user] }),
+      this.publicClient.readContract({ address: this.address, abi: EXAGENT_VAULT_ABI, functionName: "canWithdraw", args: [user] })
+    ]);
+    const assetsValue = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "convertToAssets",
+      args: [effectiveShares]
+    });
+    return {
+      shares,
+      effectiveShares,
+      pendingWithdrawals,
+      assetsValue,
+      userHighWaterMark,
+      canWithdraw: canWithdrawResult[0],
+      cooldownRemaining: canWithdrawResult[1]
+    };
+  }
+  /**
+   * Get current share price (assets per share, scaled to 1e18)
+   */
+  async getSharePrice() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "sharePrice"
+    });
+  }
+  /**
+   * Preview deposit - get shares for given assets
+   */
+  async previewDeposit(assets) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "previewDeposit",
+      args: [assets]
+    });
+  }
+  /**
+   * Preview withdrawal - get assets for given shares
+   */
+  async previewRedeem(shares) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "previewRedeem",
+      args: [shares]
+    });
+  }
+  /**
+   * Get max deposit amount
+   */
+  async maxDeposit(receiver) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "maxDeposit",
+      args: [receiver]
+    });
+  }
+  /**
+   * Get max withdrawal amount
+   */
+  async maxWithdraw(owner) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "maxWithdraw",
+      args: [owner]
+    });
+  }
+  /**
+   * Get rate limit status
+   */
+  async getRateLimitStatus() {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "getRateLimitStatus"
+    });
+    return { remaining: result[0], periodEnds: result[1] };
+  }
+  /**
+   * Get pending withdrawal request
+   */
+  async getPendingWithdrawal(requestId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "getPendingWithdrawal",
+      args: [requestId]
+    });
+    return {
+      requestId,
+      owner: result[0],
+      receiver: result[1],
+      shares: result[2],
+      requestTime: result[3],
+      processed: result[4],
+      claimableAt: result[5]
+    };
+  }
+  // ============ Write Functions ============
+  /**
+   * Deposit assets into the vault
+   * @param assets Amount of underlying asset to deposit
+   * @param receiver Address to receive vault shares
+   * @returns Transaction hash
+   */
+  async deposit(assets, receiver) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const to = receiver ?? this.account.address;
+    const hash = await this.walletClient.writeContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "deposit",
+      args: [assets, to],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Withdraw assets from the vault
+   * @param assets Amount of underlying asset to withdraw
+   * @param receiver Address to receive assets
+   * @param owner Address whose shares to burn (defaults to caller)
+   * @returns Transaction hash
+   */
+  async withdraw(assets, receiver, owner) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const to = receiver ?? this.account.address;
+    const from = owner ?? this.account.address;
+    const hash = await this.walletClient.writeContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "withdraw",
+      args: [assets, to, from],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Redeem shares for assets
+   * @param shares Amount of shares to redeem
+   * @param receiver Address to receive assets
+   * @param owner Address whose shares to burn (defaults to caller)
+   * @returns Transaction hash
+   */
+  async redeem(shares, receiver, owner) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const to = receiver ?? this.account.address;
+    const from = owner ?? this.account.address;
+    const hash = await this.walletClient.writeContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "redeem",
+      args: [shares, to, from],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Request a queued withdrawal (for large amounts)
+   * @param shares Amount of shares to withdraw
+   * @param receiver Address to receive assets
+   * @returns Transaction hash
+   */
+  async requestWithdrawal(shares, receiver) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const to = receiver ?? this.account.address;
+    const hash = await this.walletClient.writeContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_ABI,
+      functionName: "requestWithdrawal",
+      args: [shares, to],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Claim a pending withdrawal request
+   * @param requestId The withdrawal request ID
+   * @returns Transaction hash
+   */
+  async claimWithdrawal(requestId) {
+    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_VAULT_ABI,
+      functionName: "claimWithdrawal",
+      args: [requestId],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Cancel a pending withdrawal request
+   * @param requestId The withdrawal request ID
+   * @returns Transaction hash
+   */
+  async cancelWithdrawal(requestId) {
+    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_VAULT_ABI,
+      functionName: "cancelWithdrawal",
+      args: [requestId],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Emergency withdrawal (bypasses cooldown, forfeits pending rewards)
+   * @returns Transaction hash
+   */
+  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_VAULT_ABI,
+      functionName: "emergencyWithdraw",
+      args: [],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Approve vault to spend underlying asset
+   * @param assetAddress The asset token address
+   * @param amount Amount to approve
+   * @returns Transaction hash
+   */
+  async approveAsset(assetAddress, amount) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const hash = await this.walletClient.writeContract({
+      address: assetAddress,
+      abi: ERC20_APPROVE_ABI,
+      functionName: "approve",
+      args: [this.address, amount],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+};
+
+// src/contracts/staking.ts
+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: "totalVeEXA", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  { type: "function", name: "registry", inputs: [], outputs: [{ type: "address" }], 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: "PRECISION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
+  // ============ Staking Functions ============
+  {
+    type: "function",
+    name: "stake",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "lockDuration", type: "uint256" }
+    ],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  { type: "function", name: "unstake", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "extendLock",
+    inputs: [{ name: "newLockDuration", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  // ============ Reward Functions ============
+  { type: "function", name: "claimRewards", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  { type: "function", name: "claimRewardsMulti", inputs: [], outputs: [], stateMutability: "nonpayable" },
+  {
+    type: "function",
+    name: "claimRewardsToken",
+    inputs: [{ name: "token", type: "address" }],
+    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" },
+  {
+    type: "function",
+    name: "redelegate",
+    inputs: [{ name: "newAgentId", type: "uint256" }],
+    outputs: [],
+    stateMutability: "nonpayable"
+  },
+  // ============ View Functions ============
+  {
+    type: "function",
+    name: "stakes",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [
+      { name: "amount", type: "uint256" },
+      { name: "unlockTime", type: "uint256" },
+      { name: "lockDuration", type: "uint256" },
+      { name: "vEXABalance", type: "uint256" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getVeEXABalance",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "calculateVeEXA",
+    inputs: [
+      { name: "amount", type: "uint256" },
+      { name: "lockDuration", type: "uint256" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "pure"
+  },
+  {
+    type: "function",
+    name: "pendingRewards",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "pendingRewardsForToken",
+    inputs: [
+      { name: "user", type: "address" },
+      { name: "token", type: "address" }
+    ],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getDelegatedAgent",
+    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" }
+    ],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getDiscountTier",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ name: "discountBps", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getRewardTokens",
+    inputs: [],
+    outputs: [{ type: "address[]" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "delegatedTo",
+    inputs: [{ name: "user", type: "address" }],
+    outputs: [{ type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "userDelegatedVeEXA",
+    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" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "isRewardToken",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: [{ type: "bool" }],
+    stateMutability: "view"
+  },
+  // ============ Events ============
+  {
+    type: "event",
+    name: "Staked",
+    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 }
+    ]
+  },
+  {
+    type: "event",
+    name: "Unstaked",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "LockExtended",
+    inputs: [
+      { 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 }
+    ]
+  },
+  {
+    type: "event",
+    name: "Delegated",
+    inputs: [
+      { name: "delegator", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "veEXAAmount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "Undelegated",
+    inputs: [
+      { name: "delegator", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "veEXAAmount", type: "uint256", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "MultiTokenRewardsClaimed",
+    inputs: [
+      { name: "user", type: "address", indexed: true },
+      { name: "token", type: "address", indexed: true },
+      { name: "amount", type: "uint256", indexed: false }
+    ]
+  }
+];
+var ERC20_APPROVE_ABI2 = [
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ type: "bool" }],
+    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
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  chain;
+  account;
+  constructor(stakingAddress, publicClient, walletClient, chain, account) {
+    this.address = stakingAddress;
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.chain = chain;
+    this.account = account;
+  }
+  // ============ Staking Write Functions ============
+  /**
+   * Stake EXA tokens to receive vEXA voting power
+   * @param amount Amount of EXA to stake (in wei)
+   * @param lockDuration Lock duration in seconds (30 days to 2 years)
+   * @returns Transaction hash
+   *
+   * @example
+   * ```typescript
+   * // Stake 1000 EXA for 6 months
+   * const tx = await staking.stake(
+   *   parseEther('1000'),
+   *   BigInt(180 * 24 * 60 * 60) // 180 days in seconds
+   * );
+   * ```
+   */
+  async stake(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: "stake",
+      args: [amount, lockDuration],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Unstake EXA tokens after lock expires
+   * @returns Transaction hash
+   * @throws Error if lock has not expired
+   */
+  async unstake() {
+    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: [],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Extend lock duration for additional voting power
+   * @param newLockDuration New lock duration in seconds (must be longer than remaining)
+   * @returns Transaction hash
+   */
+  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: "extendLock",
+      args: [newLockDuration],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  // ============ Reward Write Functions ============
+  /**
+   * Claim accumulated EXA rewards
+   * @returns Transaction hash
+   */
+  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: "claimRewards",
+      args: [],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Claim all pending multi-token rewards (ETH, USDC, etc.)
+   * @returns Transaction hash
+   */
+  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: "claimRewardsMulti",
+      args: [],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Claim pending rewards for a specific token
+   * @param token The reward token address to claim
+   * @returns Transaction hash
+   */
+  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: "claimRewardsToken",
+      args: [token],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  // ============ Delegation Write Functions ============
+  /**
+   * Delegate vEXA voting power to an agent ("Agent Wars")
+   * @param agentId The agent ID to delegate to
+   * @returns Transaction hash
+   */
+  async delegate(agentId) {
+    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],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Remove delegation from current agent
+   * @returns Transaction hash
+   */
+  async undelegate() {
+    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",
+      args: [],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  /**
+   * Re-delegate to a different agent (undelegate + delegate in one tx)
+   * @param newAgentId The new agent ID to delegate to
+   * @returns Transaction hash
+   */
+  async redelegate(newAgentId) {
+    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],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  // ============ Read Functions ============
+  /**
+   * Get comprehensive staking info for a user
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Staking info with amount, unlock time, and vEXA balance
+   */
+  async getStakeInfo(userAddress) {
+    const user = userAddress ?? this.account?.address;
+    if (!user) {
+      throw new Error("User address required");
+    }
+    const [stakeResult, currentVeEXA] = await Promise.all([
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "stakes",
+        args: [user]
+      }),
+      this.publicClient.readContract({
+        address: this.address,
+        abi: EXAGENT_STAKING_ABI,
+        functionName: "getVeEXABalance",
+        args: [user]
+      })
+    ]);
+    const stake = stakeResult;
+    const now = BigInt(Math.floor(Date.now() / 1e3));
+    const isUnlocked = stake[1] <= now;
+    const remainingLockTime = isUnlocked ? 0n : stake[1] - now;
+    return {
+      amount: stake[0],
+      unlockTime: stake[1],
+      lockDuration: stake[2],
+      vEXABalance: stake[3],
+      currentVeEXA,
+      isUnlocked,
+      remainingLockTime
+    };
+  }
+  /**
+   * Get current vEXA balance (with time decay applied)
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Current vEXA balance
+   */
+  async getVeEXABalance(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: "getVeEXABalance",
+      args: [user]
+    });
+  }
+  /**
+   * Get the agent ID a user is delegating to
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Agent ID (0 if not delegating)
+   */
+  async getDelegatedAgent(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: "getDelegatedAgent",
+      args: [user]
+    });
+  }
+  /**
+   * Get delegation stats for an agent
+   * @param agentId The agent ID to check
+   * @returns Delegation info with total vEXA and delegator count
+   */
+  async getAgentDelegation(agentId) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "getAgentDelegation",
+      args: [agentId]
+    });
+    return {
+      totalVeEXA: result[0],
+      delegatorCount: result[1]
+    };
+  }
+  /**
+   * Get trading fee discount tier for a user
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Discount tier name and basis points
+   */
+  async getDiscountTier(userAddress) {
+    const user = userAddress ?? this.account?.address;
+    if (!user) {
+      throw new Error("User address required");
+    }
+    const discountBps = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "getDiscountTier",
+      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
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Pending reward amount in wei
+   */
+  async pendingRewards(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: "pendingRewards",
+      args: [user]
+    });
+  }
+  /**
+   * Get pending rewards for a specific token
+   * @param token The reward token address
+   * @param userAddress Address to check (defaults to connected wallet)
+   * @returns Pending reward amount in wei
+   */
+  async pendingRewardsMulti(token, 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: "pendingRewardsForToken",
+      args: [user, token]
+    });
+  }
+  /**
+   * Get list of whitelisted reward tokens
+   * @returns Array of reward token addresses
+   */
+  async getRewardTokens() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "getRewardTokens"
+    });
+  }
+  /**
+   * Check if a token is whitelisted for rewards
+   * @param token The token address to check
+   * @returns True if token is whitelisted
+   */
+  async isRewardToken(token) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "isRewardToken",
+      args: [token]
+    });
+  }
+  /**
+   * Get total staked EXA across all users
+   * @returns Total staked amount in wei
+   */
+  async getTotalStaked() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "totalStaked"
+    });
+  }
+  /**
+   * Get total vEXA supply across all users
+   * @returns Total vEXA supply
+   */
+  async getTotalVeEXA() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "totalVeEXA"
+    });
+  }
+  /**
+   * Calculate vEXA balance for a given stake (preview)
+   * @param amount Amount of EXA to stake
+   * @param lockDuration Lock duration in seconds
+   * @returns Expected vEXA balance
+   */
+  async calculateVeEXA(amount, lockDuration) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "calculateVeEXA",
+      args: [amount, lockDuration]
+    });
+  }
+  /**
+   * Get the EXA token address
+   * @returns EXA token contract address
+   */
+  async getExaTokenAddress() {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_STAKING_ABI,
+      functionName: "exaToken"
+    });
+  }
+  // ============ Helper Functions ============
+  /**
+   * Approve EXA token spending for staking
+   * @param amount Amount to approve
+   * @returns Transaction hash
+   */
+  async approveExa(amount) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for write operations");
+    }
+    const exaToken = await this.getExaTokenAddress();
+    const hash = await this.walletClient.writeContract({
+      address: exaToken,
+      abi: ERC20_APPROVE_ABI2,
+      functionName: "approve",
+      args: [this.address, amount],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  // ============ Lock Duration Constants ============
+  /** Minimum lock duration: 30 days in seconds */
+  static MIN_LOCK_DURATION = 30n * 24n * 60n * 60n;
+  /** Maximum lock duration: 2 years in seconds */
+  static MAX_LOCK_DURATION = 730n * 24n * 60n * 60n;
+  /** 1 month lock duration in seconds */
+  static LOCK_1_MONTH = 30n * 24n * 60n * 60n;
+  /** 3 months lock duration in seconds */
+  static LOCK_3_MONTHS = 90n * 24n * 60n * 60n;
+  /** 6 months lock duration in seconds */
+  static LOCK_6_MONTHS = 180n * 24n * 60n * 60n;
+  /** 1 year lock duration in seconds */
+  static LOCK_1_YEAR = 365n * 24n * 60n * 60n;
+  /** 2 years lock duration in seconds */
+  static LOCK_2_YEARS = 730n * 24n * 60n * 60n;
+};
+
+// src/constants.ts
+import { base, baseSepolia } from "viem/chains";
+var CHAIN_CONFIG = {
+  mainnet: base,
+  testnet: baseSepolia
+};
+var CONTRACT_ADDRESSES = {
+  mainnet: {
+    agentRegistry: "0x0000000000000000000000000000000000000000",
+    // To be deployed
+    exaToken: "0x0000000000000000000000000000000000000000",
+    staking: "0x0000000000000000000000000000000000000000",
+    router: "0x0000000000000000000000000000000000000000",
+    vaultFactory: "0x0000000000000000000000000000000000000000",
+    feeCollector: "0x0000000000000000000000000000000000000000",
+    buyback: "0x0000000000000000000000000000000000000000",
+    serviceEscrow: "0x0000000000000000000000000000000000000000"
+  },
+  testnet: {
+    agentRegistry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
+    // V4 UUPS proxy, one-agent-per-wallet
+    exaToken: "0x66c39b0ad96B3f5eE198Fef913c6636353a48A87",
+    staking: "0x439441468e1b1b616E9D36b80969C241F261A011",
+    // V2 with delegation
+    router: "0xc0c27eEE047E414CD716D06C2444CF2073113d5C",
+    // V3 with config epochs
+    vaultFactory: "0x5c099daaE33801a907Bb57011c6749655b55dc75",
+    // V2 with requirements
+    feeCollector: "0xcB57b03a50df054b9C738Df1324C17A4fDe4fe46",
+    buyback: "0x35cdEa810A130A846265682e5c71A68A507aB895",
+    serviceEscrow: "0x74a3496b148DEE735ac388299aF9Ac2F7C4EdCBf"
+  }
+};
+var DEX_ADDRESSES = {
+  // Aerodrome
+  aerodromeRouter: "0xcF77a3Ba9A5CA399B7c97c74d54e5b1Beb874E43",
+  aerodromeSlipstream: "0xBE6D8f0d05cC4be24d5167a3eF062215bE6D18a5",
+  // Uniswap
+  uniswapUniversalRouter: "0x198EF79F1F515F02dFE9e3115eD9fC07183f02fC",
+  uniswapV4Router: "0x6ff5693b99212da76ad316178a184ab56d299b43",
+  // Common tokens
+  WETH: "0x4200000000000000000000000000000000000006",
+  USDC: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913"
+};
+var ZERO_X_CONFIG = {
+  baseUrl: "https://api.0x.org",
+  chainId: 8453
+  // Base
+};
+var EXAGENT_API_CONFIG = {
+  mainnet: "https://api.exagent.io",
+  testnet: "https://api.testnet.exagent.io"
+};
+
+// src/client.ts
+var ExagentClient = class {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  account;
+  network;
+  apiKey;
+  // Contract interfaces
+  registry;
+  staking;
+  // Cached agent ID
+  _agentId;
+  constructor(config) {
+    this.network = config.network ?? "testnet";
+    this.apiKey = config.apiKey;
+    const chain = CHAIN_CONFIG[this.network];
+    this.publicClient = createPublicClient({
+      chain,
+      transport: http(config.rpcUrl)
+    });
+    if (config.walletClient) {
+      this.walletClient = config.walletClient;
+      this.account = config.walletClient.account;
+    } else if (config.privateKey) {
+      this.account = privateKeyToAccount(config.privateKey);
+      this.walletClient = createWalletClient({
+        account: this.account,
+        chain,
+        transport: http(config.rpcUrl)
+      });
+    } else {
+      throw new Error("Either privateKey or walletClient must be provided");
+    }
+    const addresses = CONTRACT_ADDRESSES[this.network];
+    this.registry = new ExagentRegistry(
+      addresses.agentRegistry,
+      this.publicClient,
+      this.walletClient,
+      chain,
+      this.account
+    );
+    this.staking = new ExagentStaking(
+      addresses.staking,
+      this.publicClient,
+      this.walletClient,
+      chain,
+      this.account
+    );
+  }
+  // ============ Agent Registration ============
+  /**
+   * Register as a new agent on Exagent
+   * @param metadata Agent metadata (will be uploaded to IPFS)
+   * @returns The assigned agent ID
+   * @throws Error if wallet already owns an agent (one agent per wallet rule)
+   */
+  async register(metadata) {
+    const { canRegister, existingAgentId } = await this.registry.canWalletRegister(this.account.address);
+    if (!canRegister) {
+      throw new Error(
+        `This wallet already owns agent #${existingAgentId}. Each wallet can only own one agent. Use a different wallet to create a new agent.`
+      );
+    }
+    const nameAvailable = await this.registry.isNameAvailable(metadata.name);
+    if (!nameAvailable) {
+      throw new Error(`Agent name "${metadata.name}" is already taken`);
+    }
+    const metadataURI = await this.uploadMetadata(metadata);
+    const hash = await this.registry.register(metadata.name, metadataURI);
+    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
+    const agentId = this.parseAgentIdFromReceipt(receipt);
+    this._agentId = agentId;
+    await this.registry.linkOwnWallet(agentId);
+    return agentId;
+  }
+  /**
+   * Check if an agent name is available for registration
+   * @param name The name to check
+   * @returns True if the name is available
+   */
+  async isNameAvailable(name) {
+    return this.registry.isNameAvailable(name);
+  }
+  /**
+   * Get agent by name (returns 0 if not found)
+   * @param name The agent name to look up
+   * @returns Agent ID or 0 if not found
+   */
+  async getAgentByName(name) {
+    return this.registry.getAgentByName(name);
+  }
+  /**
+   * Get the current agent's ID (if registered)
+   */
+  async getAgentId() {
+    if (this._agentId) return this._agentId;
+    const agentId = await this.registry.getAgentForWallet(this.account.address);
+    if (agentId > 0n) {
+      this._agentId = agentId;
+      return agentId;
+    }
+    return void 0;
+  }
+  /**
+   * Get agent profile
+   * @param agentId Optional agent ID (defaults to current agent)
+   */
+  async getAgent(agentId) {
+    const id = agentId ?? await this.getAgentId();
+    if (!id) throw new Error("Agent not registered");
+    return this.registry.getAgent(id);
+  }
+  // ============ Wallet Management ============
+  /**
+   * Link an additional wallet to this agent
+   * @param wallet Wallet address to link
+   * @param signMessage Function to sign a message with the wallet
+   */
+  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);
+    return this.registry.linkWallet(agentId, wallet, signature);
+  }
+  /**
+   * Get all wallets linked to this agent
+   */
+  async getLinkedWallets() {
+    const agentId = await this.getAgentId();
+    if (!agentId) throw new Error("Agent not registered");
+    return this.registry.getLinkedWallets(agentId);
+  }
+  // ============ 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
+   *
+   * This is the recommended way for agents to trade. All trades routed through
+   * the ExagentRouter emit TradeExecuted events that are captured by the indexer
+   * for accurate performance tracking and rankings.
+   *
+   * @param intent Trade parameters
+   * @returns Trade result with transaction hash
+   *
+   * @example
+   * ```typescript
+   * const result = await exagent.trade({
+   *   tokenIn: WETH,
+   *   tokenOut: USDC,
+   *   amountIn: parseEther('1'),
+   *   maxSlippageBps: 50,
+   * });
+   * console.log('Trade submitted:', result.hash);
+   * ```
+   */
+  async trade(intent) {
+    const agentId = await this.getAgentId();
+    if (!agentId) throw new Error("Agent not registered");
+    const routerTrade = await this.buildRouterTrade(intent, agentId);
+    for (const approval of routerTrade.approvals) {
+      await this.approveToken(
+        approval.token,
+        approval.spender,
+        BigInt(approval.amount)
+      );
+    }
+    const hash = await this.walletClient.sendTransaction({
+      account: this.account,
+      chain: CHAIN_CONFIG[this.network],
+      to: routerTrade.transaction.to,
+      data: routerTrade.transaction.data,
+      value: BigInt(routerTrade.transaction.value)
+    });
+    return {
+      hash,
+      agentId,
+      tokenIn: routerTrade.tokenIn,
+      tokenOut: routerTrade.tokenOut,
+      amountIn: routerTrade.amountIn,
+      expectedAmountOut: routerTrade.amountOut
+    };
+  }
+  /**
+   * Build a router trade transaction without executing
+   * Useful for simulation or multi-step workflows
+   */
+  async buildRouterTrade(intent, agentId) {
+    const id = agentId ?? await this.getAgentId();
+    if (!id) throw new Error("Agent not registered");
+    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 }
+      },
+      body: JSON.stringify({
+        agentId: id.toString(),
+        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 build trade: ${error.error || error.message}`);
+    }
+    return response.json();
+  }
+  /**
+   * Approve token spending for router
+   */
+  async approveToken(token, spender, amount) {
+    const approveData = this.encodeApprove(spender, amount);
+    const hash = await this.walletClient.sendTransaction({
+      account: this.account,
+      chain: CHAIN_CONFIG[this.network],
+      to: token,
+      data: approveData
+    });
+    await this.publicClient.waitForTransactionReceipt({ hash });
+    return hash;
+  }
+  /**
+   * Encode ERC20 approve calldata
+   */
+  encodeApprove(spender, amount) {
+    const selector = "0x095ea7b3";
+    const paddedSpender = spender.slice(2).padStart(64, "0");
+    const paddedAmount = amount.toString(16).padStart(64, "0");
+    return `${selector}${paddedSpender}${paddedAmount}`;
+  }
+  // ============ M2M Services ============
+  /**
+   * Request a service from another agent
+   */
+  async requestService(request) {
+    const agentId = await this.getAgentId();
+    if (!agentId) throw new Error("Agent not registered");
+    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 }
+      },
+      body: JSON.stringify({
+        requesterId: agentId.toString(),
+        ...request
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to request service: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * List available services
+   */
+  async listServices(serviceType) {
+    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}`);
+    return response.json();
+  }
+  // ============ Leaderboards ============
+  /**
+   * Get agent leaderboard
+   */
+  async getLeaderboard(options) {
+    const apiUrl = EXAGENT_API_CONFIG[this.network];
+    const params = new URLSearchParams();
+    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}`);
+    return response.json();
+  }
+  // ============ Vault Functions (Phase 4: Copy Trading) ============
+  /**
+   * Get a vault interface for interacting with an ExagentVault
+   * @param vaultAddress The vault contract address
+   * @returns ExagentVault instance
+   */
+  getVault(vaultAddress) {
+    return new ExagentVault(
+      vaultAddress,
+      this.publicClient,
+      this.walletClient,
+      CHAIN_CONFIG[this.network],
+      this.account
+    );
+  }
+  /**
+   * List all vaults for a given agent
+   * @param agentId Agent ID to get vaults for
+   * @returns Array of vault summaries
+   */
+  async getAgentVaults(agentId) {
+    const id = agentId ?? await this.getAgentId();
+    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 }
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get vaults: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * List all vaults the user has positions in
+   * @param userAddress User address (defaults to connected wallet)
+   * @returns Array of vault summaries with user position info
+   */
+  async getUserVaults(userAddress) {
+    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 }
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get user vaults: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * List top performing vaults
+   * @param options Filter options
+   * @returns Array of vault summaries sorted by performance
+   */
+  async getTopVaults(options) {
+    const apiUrl = EXAGENT_API_CONFIG[this.network];
+    const params = new URLSearchParams();
+    if (options?.asset) params.set("asset", options.asset);
+    if (options?.minTvl) params.set("minTvl", options.minTvl.toString());
+    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 }
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to get top vaults: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  /**
+   * Deposit into a vault
+   * @param vaultAddress Vault contract address
+   * @param amount Amount of underlying asset to deposit
+   * @returns Transaction hash
+   */
+  async depositToVault(vaultAddress, amount) {
+    const vault = this.getVault(vaultAddress);
+    const info = await vault.getVaultInfo();
+    await vault.approveAsset(info.asset, amount);
+    return vault.deposit(amount);
+  }
+  /**
+   * Withdraw from a vault
+   * @param vaultAddress Vault contract address
+   * @param assets Amount of underlying asset to withdraw
+   * @returns Transaction hash
+   */
+  async withdrawFromVault(vaultAddress, assets) {
+    const vault = this.getVault(vaultAddress);
+    return vault.withdraw(assets);
+  }
+  /**
+   * Redeem shares from a vault
+   * @param vaultAddress Vault contract address
+   * @param shares Amount of shares to redeem
+   * @returns Transaction hash
+   */
+  async redeemFromVault(vaultAddress, shares) {
+    const vault = this.getVault(vaultAddress);
+    return vault.redeem(shares);
+  }
+  // ============ Staking Functions ============
+  /**
+   * Stake EXA tokens to receive vEXA voting power
+   * @param amount Amount of EXA to stake (in wei)
+   * @param lockDuration Lock duration in seconds (30 days to 2 years)
+   * @returns Transaction hash
+   *
+   * @example
+   * ```typescript
+   * // Stake 1000 EXA for 6 months
+   * const tx = await exagent.stakeExa(
+   *   parseEther('1000'),
+   *   ExagentStaking.LOCK_6_MONTHS
+   * );
+   * ```
+   */
+  async stakeExa(amount, lockDuration) {
+    await this.staking.approveExa(amount);
+    return this.staking.stake(amount, lockDuration);
+  }
+  /**
+   * Unstake EXA tokens after lock expires
+   * @returns Transaction hash
+   */
+  async unstakeExa() {
+    return this.staking.unstake();
+  }
+  /**
+   * Get staking info for the connected wallet
+   * @returns Staking info including amount, unlock time, and vEXA balance
+   */
+  async getStakingInfo() {
+    return this.staking.getStakeInfo();
+  }
+  /**
+   * Get current vEXA balance for the connected wallet
+   * @returns Current vEXA balance (with time decay applied)
+   */
+  async getVeEXABalance() {
+    return this.staking.getVeEXABalance();
+  }
+  /**
+   * Delegate vEXA voting power to an agent
+   * @param agentId The agent ID to delegate to
+   * @returns Transaction hash
+   */
+  async delegateToAgent(agentId) {
+    return this.staking.delegate(agentId);
+  }
+  /**
+   * Get delegation stats for an agent
+   * @param agentId The agent ID to check
+   * @returns Delegation info with total vEXA and delegator count
+   */
+  async getAgentDelegation(agentId) {
+    return this.staking.getAgentDelegation(agentId);
+  }
+  /**
+   * Claim all pending staking rewards (EXA + multi-token)
+   * @returns Transaction hashes for EXA and multi-token claims
+   */
+  async claimAllRewards() {
+    const exaRewards = await this.staking.claimRewards();
+    const multiTokenRewards = await this.staking.claimRewardsMulti();
+    return { exaRewards, multiTokenRewards };
+  }
+  // ============ Helpers ============
+  /**
+   * Get the agent's wallet address
+   */
+  get address() {
+    return this.account.address;
+  }
+  async uploadMetadata(metadata) {
+    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 }
+      },
+      body: JSON.stringify(metadata)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to upload metadata: ${response.statusText}`);
+    }
+    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;
+  }
+};
+
+// src/contracts/vault-factory.ts
+var EXAGENT_VAULT_FACTORY_ABI = [
+  // Read functions
+  { 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: "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" },
+  {
+    type: "function",
+    name: "canCreateVault",
+    inputs: [{ name: "creator", type: "address" }],
+    outputs: [{ name: "canCreate", type: "bool" }, { name: "reason", type: "string" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "getVaultCreationRequirements",
+    inputs: [],
+    outputs: [
+      { name: "veXARequired", type: "uint256" },
+      { name: "burnFee", type: "uint256" },
+      { name: "stakingContract", type: "address" },
+      { name: "exaToken", type: "address" }
+    ],
+    stateMutability: "view"
+  },
+  // Write functions
+  {
+    type: "function",
+    name: "createVault",
+    inputs: [
+      { name: "agentId", type: "uint256" },
+      { name: "asset", type: "address" },
+      { name: "name", type: "string" },
+      { name: "symbol", type: "string" },
+      { name: "feeRecipient", type: "address" }
+    ],
+    outputs: [{ type: "address" }],
+    stateMutability: "nonpayable"
+  },
+  // Events
+  {
+    type: "event",
+    name: "VaultCreated",
+    inputs: [
+      { name: "vault", type: "address", indexed: true },
+      { name: "agentId", type: "uint256", indexed: true },
+      { name: "asset", type: "address", indexed: true },
+      { name: "creator", type: "address", indexed: false },
+      { name: "name", type: "string", indexed: false },
+      { name: "symbol", type: "string", indexed: false }
+    ]
+  },
+  {
+    type: "event",
+    name: "AllowedAssetUpdated",
+    inputs: [
+      { name: "asset", type: "address", indexed: true },
+      { name: "allowed", type: "bool", indexed: false }
+    ]
+  }
+];
+var ExagentVaultFactory = class {
+  address;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  publicClient;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  walletClient;
+  chain;
+  account;
+  constructor(factoryAddress, publicClient, walletClient, chain, account) {
+    this.address = factoryAddress;
+    this.publicClient = publicClient;
+    this.walletClient = walletClient;
+    this.chain = chain;
+    this.account = account;
+  }
+  // ============ Read Functions ============
+  /**
+   * Get vault creation requirements
+   */
+  async getRequirements() {
+    try {
+      const result = await 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
+      };
+    }
+  }
+  /**
+   * Check if an address can create a vault
+   * @param creator Address to check
+   */
+  async canCreateVault(creator) {
+    const result = await this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "canCreateVault",
+      args: [creator]
+    });
+    return {
+      canCreate: result[0],
+      reason: result[1]
+    };
+  }
+  /**
+   * Check if an asset is whitelisted for vault creation
+   * @param asset Asset address to check
+   */
+  async isAssetAllowed(asset) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "allowedAssets",
+      args: [asset]
+    });
+  }
+  /**
+   * Get existing vault for an agent and asset
+   * @param agentId Agent ID
+   * @param asset Asset address
+   * @returns Vault address or zero address if none exists
+   */
+  async getVault(agentId, asset) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "vaults",
+      args: [agentId, asset]
+    });
+  }
+  /**
+   * Get count of vaults for an agent
+   * @param agentId Agent ID
+   */
+  async getAgentVaultCount(agentId) {
+    return this.publicClient.readContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "agentVaultCount",
+      args: [agentId]
+    });
+  }
+  /**
+   * Check if agent already has a vault for an asset
+   * @param agentId Agent ID
+   * @param asset Asset address
+   */
+  async hasVault(agentId, asset) {
+    const vault = await this.getVault(agentId, asset);
+    return vault !== "0x0000000000000000000000000000000000000000";
+  }
+  // ============ Write Functions ============
+  /**
+   * Create a new vault for an agent
+   * @param options Vault creation options
+   * @returns Transaction hash
+   */
+  async createVault(options) {
+    if (!this.walletClient || !this.account) {
+      throw new Error("Wallet client required for vault creation");
+    }
+    const feeRecipient = options.feeRecipient ?? this.account.address;
+    const hash = await this.walletClient.writeContract({
+      address: this.address,
+      abi: EXAGENT_VAULT_FACTORY_ABI,
+      functionName: "createVault",
+      args: [options.agentId, options.asset, options.name, options.symbol, feeRecipient],
+      account: this.account,
+      chain: this.chain
+    });
+    return hash;
+  }
+  // ============ Convenience Methods ============
+  /**
+   * Check all requirements and create a vault if possible
+   * Returns detailed status about each requirement
+   */
+  async checkAndCreateVault(agentId, asset, name, symbol, feeRecipient) {
+    const [canCreateResult, assetAllowed, hasExisting] = await Promise.all([
+      this.canCreateVault(this.account?.address ?? "0x0000000000000000000000000000000000000000"),
+      this.isAssetAllowed(asset),
+      this.hasVault(agentId, asset)
+    ]);
+    const checks = {
+      canCreate: canCreateResult.canCreate,
+      canCreateReason: canCreateResult.reason,
+      assetAllowed,
+      hasExistingVault: hasExisting
+    };
+    if (!canCreateResult.canCreate) {
+      return {
+        success: false,
+        error: `Cannot create vault: ${canCreateResult.reason}`,
+        checks
+      };
+    }
+    if (!assetAllowed) {
+      return {
+        success: false,
+        error: `Asset ${asset} is not whitelisted for vault creation`,
+        checks
+      };
+    }
+    if (hasExisting) {
+      const existingVault = await this.getVault(agentId, asset);
+      return {
+        success: false,
+        error: `Vault already exists for this agent and asset`,
+        vaultAddress: existingVault,
+        checks
+      };
+    }
+    try {
+      const txHash = await this.createVault({
+        agentId,
+        asset,
+        name,
+        symbol,
+        feeRecipient
+      });
+      const receipt = await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+      if (receipt.status !== "success") {
+        return {
+          success: false,
+          error: "Transaction failed",
+          txHash,
+          checks
+        };
+      }
+      const vaultAddress = await this.getVault(agentId, asset);
+      return {
+        success: true,
+        vaultAddress,
+        txHash,
+        checks
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error creating vault",
+        checks
+      };
+    }
+  }
+};
+
+// src/index.ts
+var TESTNET_ADDRESSES = {
+  registry: "0xCF48C341e3FebeCA5ECB7eb2535f61A2Ba855d9C",
+  // V4 UUPS proxy
+  token: "0x66c39b0ad96B3f5eE198Fef913c6636353a48A87",
+  staking: "0x439441468e1b1b616E9D36b80969C241F261A011",
+  router: "0xc0c27eEE047E414CD716D06C2444CF2073113d5C",
+  // V3 with config epochs
+  vaultFactory: "0x5c099daaE33801a907Bb57011c6749655b55dc75",
+  feeCollector: "0xcB57b03a50df054b9C738Df1324C17A4fDe4fe46",
+  buyback: "0x35cdEa810A130A846265682e5c71A68A507aB895",
+  serviceEscrow: "0x74a3496b148DEE735ac388299aF9Ac2F7C4EdCBf",
+  usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+  // Circle's Base Sepolia USDC (only vault asset)
+};
+export {
+  CHAIN_CONFIG,
+  CONTRACT_ADDRESSES,
+  DEX_ADDRESSES,
+  DISCOUNT_TIERS,
+  EXAGENT_API_CONFIG,
+  EXAGENT_STAKING_ABI,
+  EXAGENT_VAULT_FACTORY_ABI,
+  ExagentClient,
+  ExagentRegistry,
+  ExagentStaking,
+  ExagentVault,
+  ExagentVaultFactory,
+  TESTNET_ADDRESSES,
+  ZERO_X_CONFIG
+};