@exagent/sdk 0.1.15 → 0.1.17

package/dist/index.mjs

@@ -3,7 +3,8 @@ import {
   createPublicClient,
   createWalletClient,
   http,
-  decodeErrorResult
+  decodeErrorResult,
+  maxUint256
 } from "viem";
 import { privateKeyToAccount } from "viem/accounts";
 
@@ -1163,821 +1164,6 @@ var ExagentVault = class {
   }
 };
 
-// src/contracts/staking.ts
-var EXAGENT_STAKING_ABI = [
-  // ============ State Variables ============
-  { type: "function", name: "exaToken", inputs: [], outputs: [{ type: "address" }], stateMutability: "view" },
-  { type: "function", name: "totalDeposited", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "totalLocked", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "totalVeEXA", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "totalEffectiveVeEXA", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  // ============ Constants ============
-  { type: "function", name: "MIN_LOCK_DURATION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "MAX_LOCK_DURATION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "VAULT_ACCESS_THRESHOLD", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  { type: "function", name: "PRECISION", inputs: [], outputs: [{ type: "uint256" }], stateMutability: "view" },
-  // ============ Phase 1: Deposit / Withdraw ============
-  {
-    type: "function",
-    name: "deposit",
-    inputs: [{ name: "amount", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "withdraw",
-    inputs: [{ name: "amount", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  // ============ Phase 2: Lock / Unlock ============
-  {
-    type: "function",
-    name: "lock",
-    inputs: [
-      { name: "amount", type: "uint256" },
-      { name: "lockDuration", type: "uint256" }
-    ],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  {
-    type: "function",
-    name: "extendLock",
-    inputs: [{ name: "newLockDuration", type: "uint256" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  { type: "function", name: "unlock", inputs: [], outputs: [], stateMutability: "nonpayable" },
-  { type: "function", name: "emergencyWithdraw", inputs: [], outputs: [], stateMutability: "nonpayable" },
-  // ============ Reward Functions ============
-  { type: "function", name: "claimRewards", inputs: [], outputs: [], stateMutability: "nonpayable" },
-  { type: "function", name: "claimRewardsMulti", inputs: [], outputs: [], stateMutability: "nonpayable" },
-  {
-    type: "function",
-    name: "claimRewardsToken",
-    inputs: [{ name: "token", type: "address" }],
-    outputs: [],
-    stateMutability: "nonpayable"
-  },
-  // ============ View Functions ============
-  {
-    type: "function",
-    name: "depositedAmount",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "locks",
-    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: "getEffectiveVeEXA",
-    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: "getEarningsTier",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [
-      { name: "multiplierBps", type: "uint256" },
-      { name: "tierName", type: "string" }
-    ],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getEmergencyWithdrawPenalty",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ name: "penaltyBps", type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "hasVaultAccess",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getUnlockedBalance",
-    inputs: [{ name: "user", type: "address" }],
-    outputs: [{ type: "uint256" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "getRewardTokens",
-    inputs: [],
-    outputs: [{ type: "address[]" }],
-    stateMutability: "view"
-  },
-  {
-    type: "function",
-    name: "isRewardToken",
-    inputs: [{ name: "token", type: "address" }],
-    outputs: [{ type: "bool" }],
-    stateMutability: "view"
-  },
-  // ============ Events ============
-  {
-    type: "event",
-    name: "Deposited",
-    inputs: [
-      { name: "user", type: "address", indexed: true },
-      { name: "amount", type: "uint256", indexed: false },
-      { name: "totalDeposited", type: "uint256", indexed: false }
-    ]
-  },
-  {
-    type: "event",
-    name: "Withdrawn",
-    inputs: [
-      { name: "user", type: "address", indexed: true },
-      { name: "amount", type: "uint256", indexed: false },
-      { name: "totalDeposited", type: "uint256", indexed: false }
-    ]
-  },
-  {
-    type: "event",
-    name: "Locked",
-    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: "Unlocked",
-    inputs: [
-      { name: "user", type: "address", indexed: true },
-      { name: "amount", type: "uint256", indexed: false }
-    ]
-  },
-  {
-    type: "event",
-    name: "EmergencyWithdrawal",
-    inputs: [
-      { name: "user", type: "address", indexed: true },
-      { name: "returned", type: "uint256", indexed: false },
-      { name: "penalty", type: "uint256", indexed: false },
-      { name: "penaltyBps", type: "uint256", indexed: false }
-    ]
-  },
-  {
-    type: "event",
-    name: "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: "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 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;
-    if (!chain) {
-      throw new Error("Chain parameter is required");
-    }
-    this.chain = chain;
-    this.account = account;
-  }
-  // ============ Phase 1: Deposit / Withdraw ============
-  /**
-   * Deposit EXA tokens for vault access (no lock required)
-   * @param amount Amount of EXA to deposit (in wei)
-   * @returns Transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Deposit 1000 EXA to unlock vault access
-   * const tx = await staking.deposit(parseEther('1000'));
-   * ```
-   */
-  async deposit(amount) {
-    if (!this.walletClient || !this.account) {
-      throw new Error("Wallet client required for write operations");
-    }
-    const hash = await this.walletClient.writeContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "deposit",
-      args: [amount],
-      account: this.account,
-      chain: this.chain
-    });
-    return hash;
-  }
-  /**
-   * Withdraw unlocked EXA tokens (instant, no penalty)
-   * @param amount Amount of EXA to withdraw (in wei)
-   * @returns Transaction hash
-   */
-  async withdraw(amount) {
-    if (!this.walletClient || !this.account) {
-      throw new Error("Wallet client required for write operations");
-    }
-    const hash = await this.walletClient.writeContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "withdraw",
-      args: [amount],
-      account: this.account,
-      chain: this.chain
-    });
-    return hash;
-  }
-  // ============ Phase 2: Lock / Unlock ============
-  /**
-   * Lock deposited EXA to receive vEXA voting power and earn rewards
-   * @param amount Amount of deposited EXA to lock (in wei)
-   * @param lockDuration Lock duration in seconds (30 days to 2 years)
-   * @returns Transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Lock 1000 EXA for 6 months
-   * const tx = await staking.lock(
-   *   parseEther('1000'),
-   *   ExagentStaking.LOCK_6_MONTHS
-   * );
-   * ```
-   */
-  async lock(amount, lockDuration) {
-    if (!this.walletClient || !this.account) {
-      throw new Error("Wallet client required for write operations");
-    }
-    const hash = await this.walletClient.writeContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "lock",
-      args: [amount, lockDuration],
-      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;
-  }
-  /**
-   * Unlock EXA after lock expires (normal path — no penalty)
-   * Returns locked amount to unlocked deposited balance.
-   * @returns Transaction hash
-   */
-  async unlock() {
-    if (!this.walletClient || !this.account) {
-      throw new Error("Wallet client required for write operations");
-    }
-    const hash = await this.walletClient.writeContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "unlock",
-      args: [],
-      account: this.account,
-      chain: this.chain
-    });
-    return hash;
-  }
-  /**
-   * Emergency withdrawal — instant exit from lock with graduated penalty
-   * Two-phase penalty: 50%→20% over the first quarter of the lock, then flat 20% until expiry.
-   * Penalty goes to treasury. Remaining returns to unlocked deposit balance.
-   * @returns Transaction hash
-   */
-  async emergencyWithdraw() {
-    if (!this.walletClient || !this.account) {
-      throw new Error("Wallet client required for write operations");
-    }
-    const hash = await this.walletClient.writeContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "emergencyWithdraw",
-      args: [],
-      account: this.account,
-      chain: this.chain
-    });
-    return hash;
-  }
-  // ============ Reward 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;
-  }
-  // ============ Read Functions ============
-  /**
-   * Get comprehensive staking info for a user (deposit + lock)
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Combined staking info
-   */
-  async getStakingInfo(userAddress) {
-    const user = userAddress ?? this.account?.address;
-    if (!user) {
-      throw new Error("User address required");
-    }
-    const [deposited, lockResult, currentVeEXA, vaultAccess, unlockedBalance] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "depositedAmount",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "locks",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "getVeEXABalance",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "hasVaultAccess",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "getUnlockedBalance",
-        args: [user]
-      })
-    ]);
-    const lockData = lockResult;
-    const depositedBigint = deposited;
-    const lockedAmount = lockData[0];
-    const now = BigInt(Math.floor(Date.now() / 1e3));
-    const depositInfo = {
-      deposited: depositedBigint,
-      locked: lockedAmount,
-      unlocked: unlockedBalance,
-      hasVaultAccess: vaultAccess
-    };
-    let lockInfo = null;
-    if (lockedAmount > 0n) {
-      const isUnlocked = lockData[1] <= now;
-      const remainingLockTime = isUnlocked ? 0n : lockData[1] - now;
-      lockInfo = {
-        amount: lockData[0],
-        unlockTime: lockData[1],
-        lockDuration: lockData[2],
-        vEXABalance: lockData[3],
-        currentVeEXA,
-        isUnlocked,
-        remainingLockTime
-      };
-    }
-    return { deposit: depositInfo, lock: lockInfo };
-  }
-  /**
-   * Get deposit info for a user
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Deposit info
-   */
-  async getDepositInfo(userAddress) {
-    const user = userAddress ?? this.account?.address;
-    if (!user) {
-      throw new Error("User address required");
-    }
-    const [deposited, lockResult, vaultAccess, unlockedBalance] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "depositedAmount",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "locks",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "hasVaultAccess",
-        args: [user]
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_STAKING_ABI,
-        functionName: "getUnlockedBalance",
-        args: [user]
-      })
-    ]);
-    const lockData = lockResult;
-    return {
-      deposited,
-      locked: lockData[0],
-      unlocked: unlockedBalance,
-      hasVaultAccess: vaultAccess
-    };
-  }
-  /**
-   * 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 effective vEXA (with tier multiplier applied)
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Effective vEXA balance
-   */
-  async getEffectiveVeEXA(userAddress) {
-    const user = userAddress ?? this.account?.address;
-    if (!user) {
-      throw new Error("User address required");
-    }
-    return this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "getEffectiveVeEXA",
-      args: [user]
-    });
-  }
-  /**
-   * Check if user has vault access (meets deposit threshold)
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns True if user can access vaults
-   */
-  async hasVaultAccess(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: "hasVaultAccess",
-      args: [user]
-    });
-  }
-  /**
-   * Get earnings tier for a user (Bronze/Silver/Gold/Platinum/Diamond)
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Tier info with multiplier and name
-   */
-  async getEarningsTier(userAddress) {
-    const user = userAddress ?? this.account?.address;
-    if (!user) {
-      throw new Error("User address required");
-    }
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "getEarningsTier",
-      args: [user]
-    });
-    return {
-      multiplierBps: result[0],
-      tierName: result[1]
-    };
-  }
-  /**
-   * Get current emergency withdrawal penalty for a user
-   * @param userAddress Address to check (defaults to connected wallet)
-   * @returns Penalty in basis points (5000 = 50% at lock start, ramps to 2000 over first 25% of lock, then flat 2000)
-   */
-  async getEmergencyWithdrawPenalty(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: "getEmergencyWithdrawPenalty",
-      args: [user]
-    });
-  }
-  /**
-   * 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 EXA deposited across all users
-   * @returns Total deposited amount in wei
-   */
-  async getTotalDeposited() {
-    return this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "totalDeposited"
-    });
-  }
-  /**
-   * Get total EXA locked across all users
-   * @returns Total locked amount in wei
-   */
-  async getTotalLocked() {
-    return this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_STAKING_ABI,
-      functionName: "totalLocked"
-    });
-  }
-  /**
-   * 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 lock (preview)
-   * @param amount Amount of EXA to lock
-   * @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 deposits
-   * @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 } from "viem/chains";
 var SDK_VERSION = "0.1.14";
@@ -1994,12 +1180,9 @@ var CHAIN_CONFIG = {
 var CONTRACT_ADDRESSES = {
   mainnet: {
     agentRegistry: "0x2261706C751F8ac5cdDb481B7b56EA2137d4A723",
-    exaToken: "0x13403Fb738C97cF7564F279288468c140AaEd05c",
-    staking: "0xe925727B21f1B86008f291E8f3102345A57B6c17",
     router: "0x1BCFa13f677fDCf697D8b7d5120f544817F1de1A",
-    vaultFactory: "0x5b90C7F9F02F9130a92481360E9aa5Be4fcc9500",
-    feeCollector: "0xe66328a964AF93bEF2eDB226D039C35aE6e66De1",
-    buyback: "0x39967532b640B2f735548c7a5b46d8D890A0B2f2",
+    vaultFactory: "0x1E0e4E445A9fda2e7aBBfFEcA80392ABb0921554",
+    feeCollector: "0x00Ab9847049b5496619dFDd1A7bd36FA49eB7195",
     serviceEscrow: "0x63A4d1dA774422EFC2cc57d71F948231BD812516"
   }
 };
@@ -2023,19 +1206,12 @@ var EXAGENT_API_CONFIG = {
   mainnet: "https://exagent-api.onrender.com"
 };
 var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
-var PHASE_1_CONTRACTS = /* @__PURE__ */ new Set([
-  "agentRegistry",
-  "exaToken",
-  "staking",
-  "router",
-  "feeCollector"
-]);
 function validateContractAddresses(network) {
   const addresses = CONTRACT_ADDRESSES[network];
-  const missingPhase1 = Object.entries(addresses).filter(([name, addr]) => PHASE_1_CONTRACTS.has(name) && addr === ZERO_ADDRESS).map(([name]) => name);
-  if (missingPhase1.length > 0) {
+  const missing = Object.entries(addresses).filter(([, addr]) => addr === ZERO_ADDRESS).map(([name]) => name);
+  if (missing.length > 0) {
     throw new Error(
-      `Mainnet Phase 1 contracts not deployed. Missing: ${missingPhase1.join(", ")}. Update @exagent/sdk to the latest version.`
+      `Contract addresses not deployed on ${network}. Missing: ${missing.join(", ")}. Update @exagent/sdk to the latest version.`
     );
   }
 }
@@ -2067,7 +1243,6 @@ var ExagentClient = class {
   apiKey;
   // Contract interfaces
   registry;
-  staking;
   // Cached agent ID
   _agentId;
   constructor(config) {
@@ -2102,13 +1277,6 @@ var ExagentClient = class {
       chain,
       this.account
     );
-    this.staking = new ExagentStaking(
-      addresses.staking,
-      this.publicClient,
-      this.walletClient,
-      chain,
-      this.account
-    );
   }
   /** Standard headers for all API requests (includes SDK version for gating) */
   apiHeaders(contentType) {
@@ -2257,7 +1425,7 @@ var ExagentClient = class {
       await this.approveToken(
         approval.token,
         approval.spender,
-        amount
+        maxUint256
       );
     }
     const txParams = {
@@ -2278,6 +1446,7 @@ var ExagentClient = class {
     } catch (err) {
       const errorData = err?.data;
       if (errorData && errorData.length > 2) {
+        console.error(`Gas estimation revert data: ${errorData}`);
         try {
           const decoded = decodeErrorResult({
             abi: [...EXAGENT_ROUTER_ABI, ...EXAGENT_REGISTRY_ABI],
@@ -2286,6 +1455,7 @@ var ExagentClient = class {
           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"}`);
@@ -2350,7 +1520,9 @@ var ExagentClient = class {
     }
   }
   /**
-   * Approve token spending for router
+   * 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);
@@ -2360,7 +1532,12 @@ var ExagentClient = class {
       to: token,
       data: approveData
     });
-    await this.publicClient.waitForTransactionReceipt({ hash });
+    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;
   }
   /**
@@ -2521,113 +1698,6 @@ var ExagentClient = class {
     const vault = this.getVault(vaultAddress);
     return vault.redeem(shares);
   }
-  // ============ Staking Functions ============
-  /**
-   * Deposit EXA tokens for vault access (no lock required)
-   * @param amount Amount of EXA to deposit (in wei)
-   * @returns Transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Deposit 1000 EXA to unlock vault access
-   * const tx = await exagent.depositExa(parseEther('1000'));
-   * ```
-   */
-  async depositExa(amount) {
-    await this.staking.approveExa(amount);
-    return this.staking.deposit(amount);
-  }
-  /**
-   * Withdraw unlocked EXA tokens (instant, no penalty)
-   * @param amount Amount of EXA to withdraw (in wei)
-   * @returns Transaction hash
-   */
-  async withdrawExa(amount) {
-    return this.staking.withdraw(amount);
-  }
-  /**
-   * Lock deposited EXA to receive vEXA voting power and earn rewards
-   * @param amount Amount of deposited EXA to lock (in wei)
-   * @param lockDuration Lock duration in seconds (30 days to 2 years)
-   * @returns Transaction hash
-   *
-   * @example
-   * ```typescript
-   * // Lock 1000 EXA for 6 months
-   * const tx = await exagent.lockExa(
-   *   parseEther('1000'),
-   *   ExagentStaking.LOCK_6_MONTHS
-   * );
-   * ```
-   */
-  async lockExa(amount, lockDuration) {
-    return this.staking.lock(amount, lockDuration);
-  }
-  /**
-   * Unlock EXA after lock expires (no penalty)
-   * @returns Transaction hash
-   */
-  async unlockExa() {
-    return this.staking.unlock();
-  }
-  /**
-   * Emergency withdrawal from active lock (graduated 50%→20% penalty)
-   * @returns Transaction hash
-   */
-  async emergencyWithdrawExa() {
-    return this.staking.emergencyWithdraw();
-  }
-  /**
-   * Get comprehensive staking info (deposit + lock) for the connected wallet
-   * @returns Staking info including deposit status and lock status
-   */
-  async getStakingInfo() {
-    return this.staking.getStakingInfo();
-  }
-  /**
-   * Get deposit info for the connected wallet
-   * @returns Deposit info (deposited, locked, unlocked, vault access)
-   */
-  async getDepositInfo() {
-    return this.staking.getDepositInfo();
-  }
-  /**
-   * Get current vEXA balance for the connected wallet
-   * @returns Current vEXA balance (with time decay applied)
-   */
-  async getVeEXABalance() {
-    return this.staking.getVeEXABalance();
-  }
-  /**
-   * Check if connected wallet has vault access (meets deposit threshold)
-   * @returns True if user can access vaults
-   */
-  async hasVaultAccess() {
-    return this.staking.hasVaultAccess();
-  }
-  /**
-   * Get earnings tier for the connected wallet
-   * @returns Tier info with multiplier and name
-   */
-  async getEarningsTier() {
-    return this.staking.getEarningsTier();
-  }
-  /**
-   * Get emergency withdrawal penalty for the connected wallet
-   * @returns Penalty in basis points (5000 = 50% at start, 2000 = 20% near expiry)
-   */
-  async getEmergencyWithdrawPenalty() {
-    return this.staking.getEmergencyWithdrawPenalty();
-  }
-  /**
-   * Claim all pending staking rewards (EXA + multi-token)
-   * @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 };
-  }
   // ============ ERC-8004 Global Agent Identity ============
   /**
    * Get the ERC-8004 global agent identifier for the current agent
@@ -2724,20 +1794,9 @@ var EXAGENT_VAULT_FACTORY_ABI = [
   { 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: "canCreateVerifiedVault",
-    inputs: [{ name: "agentId", type: "uint256" }],
-    outputs: [{ name: "isVerified", type: "bool" }, { name: "reason", type: "string" }],
-    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",
@@ -2798,12 +1857,7 @@ var ExagentVaultFactory = class {
    * Get vault creation requirements (mainnet: seed-based, no burn fee)
    */
   async getRequirements() {
-    const [veXARequired, minSeedAmount, unverifiedCapMultiplier, verifiedCapMultiplier, stakingContract] = await Promise.all([
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "VERIFIED_VEXA_REQUIREMENT"
-      }),
+    const [minSeedAmount, unverifiedCapMultiplier, verifiedCapMultiplier] = await Promise.all([
       this.publicClient.readContract({
         address: this.address,
         abi: EXAGENT_VAULT_FACTORY_ABI,
@@ -2818,52 +1872,29 @@ var ExagentVaultFactory = class {
         address: this.address,
         abi: EXAGENT_VAULT_FACTORY_ABI,
         functionName: "VERIFIED_CAP_MULTIPLIER"
-      }),
-      this.publicClient.readContract({
-        address: this.address,
-        abi: EXAGENT_VAULT_FACTORY_ABI,
-        functionName: "stakingContract"
       })
     ]);
     return {
-      veXARequired,
       minSeedAmount,
       unverifiedCapMultiplier,
-      verifiedCapMultiplier,
-      stakingContract
+      verifiedCapMultiplier
     };
   }
   /**
-   * Check if an address can create a vault
+   * 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) {
-    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 agent can create a verified vault (higher deposit cap)
-   * @param agentId Agent ID to check
-   */
-  async canCreateVerifiedVault(agentId) {
-    const result = await this.publicClient.readContract({
-      address: this.address,
-      abi: EXAGENT_VAULT_FACTORY_ABI,
-      functionName: "canCreateVerifiedVault",
-      args: [agentId]
-    });
-    return {
-      isVerified: result[0],
-      reason: result[1]
-    };
+    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
@@ -3015,11 +2046,9 @@ export {
   EXAGENT_API_CONFIG,
   EXAGENT_REGISTRY_ABI,
   EXAGENT_ROUTER_ABI,
-  EXAGENT_STAKING_ABI,
   EXAGENT_VAULT_FACTORY_ABI,
   ExagentClient,
   ExagentRegistry,
-  ExagentStaking,
   ExagentVault,
   ExagentVaultFactory,
   SDK_VERSION,