@exagent/sdk 0.1.21 → 0.2.1

package/dist/index.mjs

@@ -1,2136 +0,0 @@
-// src/client.ts
-import {
-  createPublicClient,
-  createWalletClient,
-  http,
-  decodeErrorResult,
-  maxUint256,
-  keccak256 as keccak2562,
-  toHex
-} from "viem";
-import { privateKeyToAccount } from "viem/accounts";
-
-// src/contracts/registry.ts
-import {
-  encodePacked,
-  keccak256
-} from "viem";
-var EXAGENT_REGISTRY_ABI = [
-  {
-    type: "function",
-    name: "registerAgent",
-    inputs: [
-      { name: "name", type: "string" },
-      { name: "metadataURI", type: "string" },
-      { name: "riskUniverse", type: "uint8" },
-      { name: "maxPositionSizeBps", type: "uint256" },
-      { name: "maxDailyLossBps", type: "uint256" }
-    ],
-    outputs: [{ name: "agentId", type: "uint256" }],
-    stateMutability: "nonpayable"
-  },
-  {
-    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: "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"
-  },
-  // Config Epochs
-  {
-    type: "function",
-    name: "setConfig",
-    inputs: [
-      { name: "agentId", type: "uint256" },
-      { name: "configHash", type: "bytes32" }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "getConfigHash",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ name: "", type: "bytes32" }],
-    stateMutability: "view"
-  },
-  // Mainnet: Agent retirement
-  {
-    type: "function",
-    name: "retireAgent",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "retired",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "isRetired",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  // Mainnet: Risk universe token whitelists
-  {
-    type: "function",
-    name: "isTradeAllowed",
-    inputs: [
-      { name: "agentId", type: "uint256" },
-      { name: "token", type: "address" },
-      { name: "aggregator", type: "address" }
-    ],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getRiskUniverse",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "uint8" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "tradeCount",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  // Events
-  {
-    type: "event",
-    name: "AgentRetired",
-    inputs: [
-      { name: "agentId", type: "uint256", indexed: true }
-    ]
-  },
-  {
-    type: "event",
-    name: "ConfigUpdated",
-    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 }
-    ]
-  },
-  // Custom errors — must match ExagentRegistry.sol for viem to decode reverts
-  { type: "error", name: "AgentNotOwner", inputs: [] },
-  { type: "error", name: "WalletAlreadyLinked", inputs: [] },
-  { type: "error", name: "WalletNotLinked", inputs: [] },
-  { type: "error", name: "InvalidSignature", inputs: [] },
-  { type: "error", name: "TransferDisabled", inputs: [] },
-  { type: "error", name: "InvalidMetadataURI", inputs: [] },
-  { type: "error", name: "AgentDoesNotExist", inputs: [] },
-  { type: "error", name: "NameAlreadyTaken", inputs: [] },
-  { type: "error", name: "InvalidName", inputs: [] },
-  { type: "error", name: "OwnerAlreadyHasAgent", inputs: [{ name: "existingAgentId", type: "uint256" }] },
-  { type: "error", name: "InvalidRiskUniverse", inputs: [] },
-  { type: "error", name: "InvalidTradingConfig", inputs: [] },
-  { type: "error", name: "NotAuthorizedCaller", inputs: [] },
-  { type: "error", name: "MetadataValueTooLarge", inputs: [] },
-  { type: "error", name: "AgentIsRetired", inputs: [] },
-  { type: "error", name: "InvalidRiskUniverseForWhitelist", inputs: [] }
-];
-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
-   * @param riskUniverse Risk tier: 0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier
-   * @param maxPositionSizeBps Maximum position size in basis points (1-10000)
-   * @param maxDailyLossBps Maximum daily loss in basis points (1-10000)
-   * @returns Transaction hash
-   */
-  async register(name, metadataURI, riskUniverse = 1, maxPositionSizeBps = 1000n, maxDailyLossBps = 500n) {
-    if (!this.walletClient || !this.account) throw new Error("Wallet client and account required for write operations");
-    const hash = await this.walletClient.writeContract({
-      account: this.account,
-      chain: this.chain,
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "registerAgent",
-      args: [name, metadataURI, riskUniverse, maxPositionSizeBps, maxDailyLossBps]
-    });
-    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;
-  }
-  /**
-   * Generate the message hash for wallet linking.
-   * Matches the contract's keccak256(abi.encodePacked(...)) exactly.
-   * Sign the returned hash with signMessage({ raw: hash }) to produce a valid signature.
-   * @param wallet The wallet to link
-   * @param agentId The agent ID to link to
-   * @param nonce The current nonce for the wallet
-   * @returns keccak256 hash of the packed message (32 bytes)
-   */
-  static generateLinkMessage(wallet, agentId, nonce) {
-    return keccak256(encodePacked(
-      ["string", "address", "string", "uint256", "string", "uint256"],
-      ["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 };
-  }
-  // ============ 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: "setConfig",
-      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;
-  }
-  /**
-   * 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) {
-    return keccak256(encodePacked(["string", "string"], [provider, model]));
-  }
-  // ============ Agent Retirement ============
-  /**
-   * Retire an agent — marks it as retired, unlinks all wallets, allows new agent registration
-   * @param agentId The agent's ID
-   * @returns Transaction hash
-   */
-  async retireAgent(agentId) {
-    if (!this.walletClient || !this.account) throw new Error("Wallet client and account required for write operations");
-    const hash = await this.walletClient.writeContract({
-      account: this.account,
-      chain: this.chain,
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "retireAgent",
-      args: [agentId]
-    });
-    return hash;
-  }
-  /**
-   * Check if an agent is retired
-   * @param agentId The agent's ID
-   * @returns True if agent is retired
-   */
-  async isRetired(agentId) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "isRetired",
-      args: [agentId]
-    });
-    return result;
-  }
-  // ============ Risk Universe Token Eligibility ============
-  /**
-   * Check if a token trade is allowed for an agent's risk universe
-   * @param agentId The agent's ID
-   * @param token The token address to check
-   * @param aggregator The aggregator being used (for trusted aggregator bypass)
-   * @returns True if the trade is allowed
-   */
-  async isTradeAllowed(agentId, token, aggregator) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "isTradeAllowed",
-      args: [agentId, token, aggregator]
-    });
-    return result;
-  }
-  /**
-   * Get the risk universe for an agent
-   * @param agentId The agent's ID
-   * @returns Risk universe (0=Core, 1=Established, 2=Derivatives, 3=Emerging, 4=Frontier)
-   */
-  async getRiskUniverse(agentId) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "getRiskUniverse",
-      args: [agentId]
-    });
-    return Number(result);
-  }
-  /**
-   * Get trade count for an agent
-   * @param agentId The agent's ID
-   * @returns Number of recorded trades
-   */
-  async getTradeCount(agentId) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_REGISTRY_ABI,
-      functionName: "tradeCount",
-      args: [agentId]
-    });
-    return result;
-  }
-};
-
-// src/contracts/router.ts
-var EXAGENT_ROUTER_ABI = [
-  // Custom errors — must match ExagentRouterV2.sol for viem to decode reverts
-  { type: "error", name: "InvalidAgentId", inputs: [] },
-  { type: "error", name: "SwapFailed", inputs: [] },
-  { type: "error", name: "InsufficientOutput", inputs: [] },
-  { type: "error", name: "ZeroAddress", inputs: [] },
-  { type: "error", name: "ZeroAmount", inputs: [] },
-  { type: "error", name: "AggregatorNotWhitelisted", inputs: [] },
-  { type: "error", name: "ETHTransferFailed", inputs: [] },
-  { type: "error", name: "FeeBpsTooHigh", inputs: [] },
-  { type: "error", name: "NotAuthorizedForAgent", inputs: [{ name: "agentId", type: "uint256" }, { name: "caller", type: "address" }] },
-  { type: "error", name: "ConfigMismatch", inputs: [{ name: "provided", type: "bytes32" }, { name: "onChain", type: "bytes32" }] },
-  { type: "error", name: "MsgValueMismatch", inputs: [] },
-  { type: "error", name: "FeeCollectorNotSet", inputs: [] },
-  { type: "error", name: "TokenNotAllowedForAgent", inputs: [{ name: "agentId", type: "uint256" }, { name: "token", type: "address" }] },
-  { type: "error", name: "NotAuthorized", inputs: [] },
-  { type: "error", name: "RiskUniverseTooLow", inputs: [{ name: "agentId", type: "uint256" }, { name: "riskUniverse", type: "uint256" }] },
-  { type: "error", name: "FillAlreadyProcessed", inputs: [{ name: "fillId", type: "bytes32" }] }
-];
-
-// 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: "getPendingWithdrawals", inputs: [{ name: "owner", type: "address" }], outputs: [{ name: "requestIds", type: "uint256[]" }], stateMutability: "view" },
-  { type: "function", name: "getClaimableAmount", inputs: [{ name: "requestId", type: "uint256" }], outputs: [{ name: "assets", 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"
-  },
-  // V2: Safe "withdraw all"
-  { type: "function", name: "redeemMax", inputs: [{ name: "receiver", type: "address" }, { name: "owner", type: "address" }], outputs: [{ name: "assets", type: "uint256" }], stateMutability: "nonpayable" },
-  { type: "function", name: "withdrawMax", inputs: [{ name: "receiver", type: "address" }, { name: "owner", type: "address" }], outputs: [{ name: "assets", type: "uint256" }], stateMutability: "nonpayable" },
-  // V2: Emergency exit with penalty
-  { type: "function", name: "emergencyWithdraw", inputs: [], outputs: [{ name: "assets", type: "uint256" }], 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;
-    if (!chain) {
-      throw new Error("Chain parameter is required");
-    }
-    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
-    ] = 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] })
-    ]);
-    const assetsValue = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_VAULT_ABI,
-      functionName: "convertToAssets",
-      args: [effectiveShares]
-    });
-    return {
-      shares,
-      effectiveShares,
-      pendingWithdrawals,
-      assetsValue,
-      userHighWaterMark
-    };
-  }
-  /**
-   * 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;
-  }
-  /**
-   * Redeem all shares safely — charges performance fee first, then redeems remaining balance.
-   * Use this instead of redeem(fullBalance) to avoid ERC4626ExceededMaxRedeem revert.
-   * @param receiver Address to receive assets
-   * @param owner Address whose shares to burn (defaults to caller)
-   * @returns Transaction hash
-   */
-  async redeemMax(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: "redeemMax",
-      args: [to, from],
-      account: this.account,
-      chain: this.chain
-    });
-    return hash;
-  }
-  /**
-   * Withdraw all assets safely — charges performance fee first, then withdraws remaining balance.
-   * @param receiver Address to receive assets
-   * @param owner Address whose shares to burn (defaults to caller)
-   * @returns Transaction hash
-   */
-  async withdrawMax(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: "withdrawMax",
-      args: [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 with penalty (50% if vault < 7 days old, 20% otherwise).
-   * Penalty stays in the vault for remaining backers.
-   * @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/constants.ts
-import { base } from "viem/chains";
-var SDK_VERSION = "0.1.21";
-var DEFAULT_RPC_URL = "https://mainnet.base.org";
-function getRpcUrl() {
-  if (typeof process !== "undefined" && process.env) {
-    return process.env.BASE_RPC_URL || process.env.EXAGENT_RPC_URL || DEFAULT_RPC_URL;
-  }
-  return DEFAULT_RPC_URL;
-}
-var CHAIN_CONFIG = {
-  mainnet: base
-};
-var CONTRACT_ADDRESSES = {
-  mainnet: {
-    agentRegistry: "0x2261706C751F8ac5cdDb481B7b56EA2137d4A723",
-    router: "0xBfE186E2Bba9B730c8732917AE36E7AC143420d3",
-    vaultFactory: "0x3312f7C0059C03b47Df63DA4f73B79A63a874ef5",
-    feeCollector: "0x00Ab9847049b5496619dFDd1A7bd36FA49eB7195",
-    serviceEscrow: "0x63A4d1dA774422EFC2cc57d71F948231BD812516"
-  }
-};
-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://exagent-api.onrender.com"
-};
-var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-function validateContractAddresses(network) {
-  const addresses = CONTRACT_ADDRESSES[network];
-  const missing = Object.entries(addresses).filter(([, addr]) => addr === ZERO_ADDRESS).map(([name]) => name);
-  if (missing.length > 0) {
-    throw new Error(
-      `Contract addresses not deployed on ${network}. Missing: ${missing.join(", ")}. Update @exagent/sdk to the latest version.`
-    );
-  }
-}
-
-// src/types.ts
-function buildGlobalAgentId(chainId, registryAddress, agentId) {
-  return `eip155:${chainId}:${registryAddress}:${Number(agentId)}`;
-}
-function parseGlobalAgentId(globalId) {
-  const parts = globalId.split(":");
-  if (parts.length !== 4 || parts[0] !== "eip155") {
-    throw new Error(`Invalid ERC-8004 global agent ID: ${globalId}`);
-  }
-  const chainId = parseInt(parts[1], 10);
-  const registryAddress = parts[2];
-  const agentId = parseInt(parts[3], 10);
-  if (isNaN(chainId) || isNaN(agentId)) {
-    throw new Error(`Invalid ERC-8004 global agent ID: ${globalId}`);
-  }
-  return { chainId, registryAddress, agentId };
-}
-
-// src/client.ts
-var ExagentClient = class {
-  publicClient;
-  walletClient;
-  account;
-  network;
-  apiKey;
-  // Contract interfaces
-  registry;
-  // Cached agent ID
-  _agentId;
-  constructor(config) {
-    this.network = config.network ?? "mainnet";
-    this.apiKey = config.apiKey;
-    validateContractAddresses(this.network);
-    const chain = CHAIN_CONFIG[this.network];
-    const rpcUrl = config.rpcUrl || getRpcUrl();
-    const transport = http(rpcUrl, { timeout: 6e4 });
-    this.publicClient = createPublicClient({
-      chain,
-      transport
-    });
-    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
-      });
-    } 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
-    );
-  }
-  /** Standard headers for all API requests (includes SDK version for gating) */
-  apiHeaders(contentType) {
-    return {
-      ...contentType && { "Content-Type": contentType },
-      "X-Exagent-SDK-Version": SDK_VERSION,
-      ...this.apiKey && { "X-API-Key": this.apiKey }
-    };
-  }
-  // ============ Agent Registration ============
-  /**
-   * Register as a new agent on Exagent.
-   *
-   * RECOMMENDED: Register your agent at https://exagent.io instead of using this method.
-   * The website handles the full registration flow including risk universe selection,
-   * position size limits, daily loss limits, and metadata upload — all in one step.
-   * After registering on the website, use your agent ID in agent-config.json.
-   *
-   * This SDK method is available for programmatic registration but uses default
-   * risk parameters (universe=1, maxPositionSize=10%, maxDailyLoss=5%).
-   *
-   * @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;
-    const linkHash = await this.registry.linkOwnWallet(agentId);
-    await this.publicClient.waitForTransactionReceipt({ hash: linkHash });
-    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).
-   *
-   * Resolution order:
-   * 1. Cached value (from prior register() or getAgentId() call)
-   * 2. walletToAgent mapping (linked wallets)
-   * 3. Owner lookup (unlinked owner wallet)
-   *
-   * If the agent was just registered, public RPCs may return stale data (0).
-   * Use `retries` to wait for the on-chain state to propagate.
-   *
-   * @param retries Number of retries with 2s delay for stale RPC reads (default: 0)
-   */
-  async getAgentId(retries = 0) {
-    if (this._agentId) return this._agentId;
-    for (let attempt = 0; attempt <= retries; attempt++) {
-      if (attempt > 0) {
-        await new Promise((r) => setTimeout(r, 2e3));
-      }
-      const agentId = await this.registry.getAgentForWallet(this.account.address);
-      if (agentId > 0n) {
-        this._agentId = agentId;
-        return agentId;
-      }
-      const ownedAgentId = await this.registry.getAgentByOwner(this.account.address);
-      if (ownedAgentId > 0n) {
-        this._agentId = ownedAgentId;
-        return ownedAgentId;
-      }
-    }
-    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 the message hash with the wallet (use signMessage({ raw: hash }))
-   */
-  async linkWallet(wallet, signMessage) {
-    const agentId = await this.getAgentId();
-    if (!agentId) throw new Error("Agent not registered");
-    const nonce = await this.registry.getNonce(wallet);
-    const messageHash = ExagentRegistry.generateLinkMessage(wallet, agentId, nonce);
-    const signature = await signMessage({ raw: messageHash });
-    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 ============
-  /**
-   * Execute a trade through ExagentRouter
-   *
-   * All trades MUST go through the ExagentRouter. This ensures:
-   * - Trade attribution for leaderboard ranking
-   * - Protocol fee collection (0.2%)
-   * - On-chain performance tracking
-   * - Token whitelist enforcement per risk universe
-   *
-   * There is no way to trade outside the router. This is by design.
-   *
-   * @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);
-    const seen = /* @__PURE__ */ new Set();
-    for (const approval of routerTrade.approvals) {
-      const key = `${approval.token.toLowerCase()}:${approval.spender.toLowerCase()}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      if (!approval.amount) {
-        console.warn(`Skipping approval with missing amount for token ${approval.token} \u2014 0x did not return expected allowance`);
-        continue;
-      }
-      const amount = BigInt(approval.amount);
-      const existing = await this.getAllowance(
-        approval.token,
-        approval.spender
-      );
-      if (existing >= amount) continue;
-      await this.approveToken(
-        approval.token,
-        approval.spender,
-        maxUint256
-      );
-    }
-    const txParams = {
-      account: this.account,
-      chain: CHAIN_CONFIG[this.network],
-      to: routerTrade.transaction.to,
-      data: routerTrade.transaction.data,
-      value: BigInt(routerTrade.transaction.value)
-    };
-    const isETHInput = this.isETHAddress(intent.tokenIn);
-    try {
-      const estimated = await this.publicClient.estimateGas({
-        account: this.account,
-        to: routerTrade.transaction.to,
-        data: routerTrade.transaction.data,
-        value: BigInt(routerTrade.transaction.value)
-      });
-      txParams.gas = estimated * 150n / 100n;
-    } catch (err) {
-      const errorData = err?.data;
-      if (isETHInput) {
-        if (errorData && errorData.length > 2) {
-          console.error(`Gas estimation revert data: ${errorData}`);
-          try {
-            const decoded = decodeErrorResult({
-              abi: [...EXAGENT_ROUTER_ABI, ...EXAGENT_REGISTRY_ABI],
-              data: errorData
-            });
-            throw new Error(`Trade will revert: ${decoded.errorName}${decoded.args ? ` (${decoded.args.join(", ")})` : ""}`);
-          } catch (decodeErr) {
-            if (decodeErr instanceof Error && decodeErr.message.startsWith("Trade will revert:")) throw decodeErr;
-            throw new Error(`Trade will revert: unknown error selector ${errorData.slice(0, 10)} (raw: ${errorData.slice(0, 66)})`);
-          }
-        }
-        throw new Error(`Trade will revert: gas estimation failed. ${err?.message || "Unknown reason"}`);
-      }
-      if (routerTrade.gasEstimate) {
-        const apiGas = BigInt(routerTrade.gasEstimate);
-        txParams.gas = apiGas * 200n / 100n;
-        console.warn(
-          `[SDK] Local gas estimation failed for sell, using API estimate with 100% buffer: ${txParams.gas}. This is expected for some DEX routes. Warning: ${routerTrade.simulationWarning || "none"}`
-        );
-      } else {
-        txParams.gas = 800000n;
-        console.warn(
-          `[SDK] Local gas estimation failed for sell and no API estimate available. Using safe default: 800000. This may result in wasted gas if the transaction reverts.`
-        );
-      }
-    }
-    const hash = await this.walletClient.sendTransaction(txParams);
-    if (routerTrade.route && routerTrade.route.length > 0) {
-      const dexSource = [...new Set(routerTrade.route.map((r) => r.dex))].join(", ");
-      const routeApiUrl = EXAGENT_API_CONFIG[this.network];
-      fetch(`${routeApiUrl}/v1/router/trade-route`, {
-        method: "POST",
-        headers: this.apiHeaders("application/json"),
-        body: JSON.stringify({
-          txHash: hash,
-          agentId: Number(agentId),
-          dexSource,
-          route: routerTrade.route
-        })
-      }).catch(() => {
-      });
-    }
-    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];
-    let configHash = intent.configHash;
-    if (!configHash) {
-      const onChainHash = await this.registry.getConfigHash(id);
-      if (onChainHash && onChainHash !== "0x0000000000000000000000000000000000000000000000000000000000000000") {
-        configHash = onChainHash;
-      }
-    }
-    const response = await fetch(`${apiUrl}/v1/router/trade`, {
-      method: "POST",
-      headers: this.apiHeaders("application/json"),
-      body: JSON.stringify({
-        agentId: id.toString(),
-        tokenIn: intent.tokenIn,
-        tokenOut: intent.tokenOut,
-        amountIn: intent.amountIn.toString(),
-        slippageBps: intent.maxSlippageBps ?? 50,
-        taker: this.account.address,
-        ...configHash && { configHash }
-      })
-    });
-    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();
-  }
-  /**
-   * Check if an address is the ETH sentinel or WETH
-   */
-  isETHAddress(addr) {
-    const lower = addr.toLowerCase();
-    return lower === "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee" || lower === "0x0000000000000000000000000000000000000000" || lower === "0x4200000000000000000000000000000000000006";
-  }
-  /**
-   * Read current ERC-20 allowance for a (token, spender) pair
-   */
-  async getAllowance(token, spender) {
-    try {
-      const data = await this.publicClient.call({
-        to: token,
-        data: `0xdd62ed3e${this.account.address.slice(2).padStart(64, "0")}${spender.slice(2).padStart(64, "0")}`
-      });
-      if (!data.data || data.data === "0x") return 0n;
-      return BigInt(data.data);
-    } catch {
-      return 0n;
-    }
-  }
-  /**
-   * Approve token spending for router.
-   * Verifies the approval receipt succeeded — previous version silently continued
-   * on reverted approvals, causing downstream "transfer amount exceeds allowance" errors.
-   */
-  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
-    });
-    const receipt = await this.publicClient.waitForTransactionReceipt({ hash });
-    if (receipt.status === "reverted") {
-      throw new Error(
-        `Token approval reverted: approve(${spender}, ${amount}) on ${token}. The token may have non-standard approval behavior.`
-      );
-    }
-    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: this.apiHeaders("application/json"),
-      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}`, {
-      headers: this.apiHeaders()
-    });
-    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}`, {
-      headers: this.apiHeaders()
-    });
-    const data = await response.json();
-    return data.agents ?? [];
-  }
-  // ============ 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.apiHeaders()
-    });
-    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.apiHeaders()
-    });
-    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.apiHeaders()
-    });
-    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);
-  }
-  // ============ ERC-8004 Global Agent Identity ============
-  /**
-   * Get the ERC-8004 global agent identifier for the current agent
-   *
-   * Format: eip155:{chainId}:{registryAddress}:{agentId}
-   *
-   * This creates a universally unique identifier that can be used for
-   * cross-protocol agent discovery and interoperability.
-   *
-   * @returns The global agent ID string
-   * @throws Error if agent is not registered
-   *
-   * @example
-   * ```typescript
-   * const globalId = await exagent.getGlobalAgentId();
-   * // => "eip155:8453:0xABC...DEF:42"
-   * ```
-   */
-  async getGlobalAgentId() {
-    const agentId = await this.getAgentId();
-    if (!agentId) throw new Error("Agent not registered");
-    const chain = CHAIN_CONFIG[this.network];
-    const addresses = CONTRACT_ADDRESSES[this.network];
-    return buildGlobalAgentId(
-      chain.id,
-      addresses.agentRegistry,
-      agentId
-    );
-  }
-  /**
-   * Build a global agent ID for any agent (static utility)
-   *
-   * @param chainId - EVM chain ID
-   * @param registryAddress - ExagentRegistry contract address
-   * @param agentId - On-chain agent ID
-   * @returns ERC-8004 global agent identifier
-   */
-  static buildGlobalAgentId(chainId, registryAddress, agentId) {
-    return buildGlobalAgentId(chainId, registryAddress, agentId);
-  }
-  // ============ Helpers ============
-  /**
-   * Get the agent's wallet address
-   */
-  get address() {
-    return this.account.address;
-  }
-  /**
-   * Sign a message with the wallet's private key (EIP-191 personal sign)
-   * @param message The message to sign — string for UTF-8, or { raw: Hex } for raw bytes
-   * @returns The signature
-   */
-  async signMessage(message) {
-    return this.walletClient.signMessage({ account: this.account, message });
-  }
-  async uploadMetadata(metadata) {
-    const apiUrl = EXAGENT_API_CONFIG[this.network];
-    const response = await fetch(`${apiUrl}/v1/metadata/upload`, {
-      method: "POST",
-      headers: this.apiHeaders("application/json"),
-      body: JSON.stringify(metadata)
-    });
-    if (!response.ok) {
-      throw new Error(`Failed to upload metadata: ${response.statusText}`);
-    }
-    const result = await response.json();
-    return result.uri;
-  }
-  parseAgentIdFromReceipt(receipt) {
-    const registryAddress = this.registry.address.toLowerCase();
-    const AGENT_REGISTERED_TOPIC = keccak2562(
-      toHex("AgentRegistered(uint256,address,string,string)")
-    );
-    const TRANSFER_TOPIC = keccak2562(
-      toHex("Transfer(address,address,uint256)")
-    );
-    const ZERO_ADDRESS2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-    for (const log of receipt.logs) {
-      if (log.address.toLowerCase() !== registryAddress) continue;
-      if (log.topics[0] === AGENT_REGISTERED_TOPIC && log.topics[1]) {
-        return BigInt(log.topics[1]);
-      }
-    }
-    for (const log of receipt.logs) {
-      if (log.address.toLowerCase() !== registryAddress) continue;
-      if (log.topics[0] === TRANSFER_TOPIC && log.topics[1] === ZERO_ADDRESS2 && log.topics[3]) {
-        return BigInt(log.topics[3]);
-      }
-    }
-    throw new Error(
-      "Could not extract agent ID from transaction receipt.\nNeither AgentRegistered nor ERC721 Transfer event found in logs.\nCheck the transaction on BaseScan to verify registration succeeded."
-    );
-  }
-};
-
-// 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: "feeCollector", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "stakingContract", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "VERIFIED_VEXA_REQUIREMENT", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "MIN_SEED_AMOUNT", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "UNVERIFIED_CAP_MULTIPLIER", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "VERIFIED_CAP_MULTIPLIER", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "allowedAssets", inputs: [{ name: "asset", type: "address" }], outputs: [{ type: "bool" }], stateMutability: "view" },
-  { type: "function", name: "vaults", inputs: [{ name: "agentId", type: "uint256" }, { name: "asset", type: "address" }], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "agentVaultCount", inputs: [{ name: "agentId", type: "uint256" }], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  // NOTE: canCreateVault() and canCreateVerifiedVault() do not exist on the
-  // deployed ExagentVaultFactoryV2 contract. SDK methods that called these
-  // now use inline validation (allowedAssets, vaults, MIN_SEED_AMOUNT) instead.
-  // Write functions
-  {
-    type: "function",
-    name: "createVault",
-    inputs: [
-      { name: "agentId", type: "uint256" },
-      { name: "asset", type: "address" },
-      { name: "seedAmount", type: "uint256" },
-      { name: "name", type: "string" },
-      { name: "symbol", type: "string" },
-      { name: "feeRecipient", type: "address" }
-    ],
-    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;
-    if (!chain) {
-      throw new Error("Chain parameter is required");
-    }
-    this.chain = chain;
-    this.account = account;
-  }
-  // ============ Read Functions ============
-  /**
-   * Get vault creation requirements (mainnet: seed-based, no burn fee)
-   */
-  async getRequirements() {
-    const [minSeedAmount, unverifiedCapMultiplier, verifiedCapMultiplier] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "MIN_SEED_AMOUNT"
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "UNVERIFIED_CAP_MULTIPLIER"
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "VERIFIED_CAP_MULTIPLIER"
-      })
-    ]);
-    return {
-      minSeedAmount,
-      unverifiedCapMultiplier,
-      verifiedCapMultiplier
-    };
-  }
-  /**
-   * Check if an address can create a vault.
-   * Performs inline validation since the on-chain contract does not expose
-   * a canCreateVault() view function.
-   * @param creator Address to check
-   */
-  async canCreateVault(creator) {
-    try {
-      const isUsdcAllowed = await this.isAssetAllowed("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913");
-      if (!isUsdcAllowed) {
-        return { canCreate: false, reason: "USDC is not an allowed asset" };
-      }
-    } catch {
-    }
-    return { canCreate: true, reason: "" };
-  }
-  /**
-   * 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 (mainnet: requires seed amount)
-   * @param options Vault creation options including seedAmount
-   * @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.seedAmount, 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, seedAmount, 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,
-        seedAmount,
-        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
-      };
-    }
-  }
-};
-export {
-  CHAIN_CONFIG,
-  CONTRACT_ADDRESSES,
-  DEFAULT_RPC_URL,
-  DEX_ADDRESSES,
-  EXAGENT_API_CONFIG,
-  EXAGENT_REGISTRY_ABI,
-  EXAGENT_ROUTER_ABI,
-  EXAGENT_VAULT_FACTORY_ABI,
-  ExagentClient,
-  ExagentRegistry,
-  ExagentVault,
-  ExagentVaultFactory,
-  SDK_VERSION,
-  ZERO_X_CONFIG,
-  buildGlobalAgentId,
-  getRpcUrl,
-  parseGlobalAgentId
-};