@axonfi/sdk 0.5.1 → 0.5.3

package/dist/index.js

@@ -1,4 +1,4 @@
-import { keccak256, stringToBytes, createPublicClient, http, createWalletClient, erc20Abi, parseUnits } from 'viem';
+import { keccak256, stringToBytes, parseUnits, createPublicClient, http, createWalletClient, erc20Abi } from 'viem';
 import { privateKeyToAccount } from 'viem/accounts';
 import { arbitrumSepolia, arbitrum, baseSepolia, base } from 'viem/chains';
 import { scryptAsync } from '@noble/hashes/scrypt';
@@ -2544,314 +2544,6 @@ var AxonVaultFactoryAbi = [
     "inputs": []
   }
 ];
-function getChain(chainId) {
-  switch (chainId) {
-    case 8453:
-      return base;
-    case 84532:
-      return baseSepolia;
-    case 42161:
-      return arbitrum;
-    case 421614:
-      return arbitrumSepolia;
-    default:
-      throw new Error(
-        `Unsupported chainId: ${chainId}. Supported: 8453 (Base), 84532 (Base Sepolia), 42161 (Arbitrum), 421614 (Arbitrum Sepolia)`
-      );
-  }
-}
-function createAxonPublicClient(chainId, rpcUrl) {
-  return createPublicClient({
-    chain: getChain(chainId),
-    transport: http(rpcUrl)
-  });
-}
-function createAxonWalletClient(privateKey, chainId) {
-  const account = privateKeyToAccount(privateKey);
-  return createWalletClient({
-    account,
-    chain: getChain(chainId),
-    transport: http()
-    // signing is local — transport is unused but required by viem
-  });
-}
-var USDC_DECIMALS = 6n;
-var USDC_UNIT = 10n ** USDC_DECIMALS;
-function toBotConfigParams(input) {
-  return {
-    maxPerTxAmount: BigInt(Math.round(input.maxPerTxAmount * Number(USDC_UNIT))),
-    maxRebalanceAmount: BigInt(Math.round(input.maxRebalanceAmount * Number(USDC_UNIT))),
-    spendingLimits: input.spendingLimits.map((sl) => ({
-      amount: BigInt(Math.round(sl.amount * Number(USDC_UNIT))),
-      maxCount: BigInt(sl.maxCount),
-      windowSeconds: BigInt(sl.windowSeconds)
-    })),
-    aiTriggerThreshold: BigInt(Math.round(input.aiTriggerThreshold * Number(USDC_UNIT))),
-    requireAiVerification: input.requireAiVerification
-  };
-}
-var DEFAULT_RELAYER_URL = "https://relay.axonfi.xyz";
-async function getFactoryAddress(chainId, relayerUrl) {
-  const base2 = relayerUrl ?? DEFAULT_RELAYER_URL;
-  const resp = await fetch(`${base2}/v1/chains`);
-  if (!resp.ok) throw new Error(`Failed to fetch chain config from relayer [${resp.status}]`);
-  const data = await resp.json();
-  const chain = data.chains?.find((c) => c.chainId === chainId);
-  if (!chain?.factoryAddress) {
-    throw new Error(`No factory address available for chainId ${chainId}. Check the relayer's chain configuration.`);
-  }
-  return chain.factoryAddress;
-}
-async function getBotConfig(publicClient, vaultAddress, botAddress) {
-  const result = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "getBotConfig",
-    args: [botAddress]
-  });
-  return {
-    isActive: result.isActive,
-    registeredAt: result.registeredAt,
-    maxPerTxAmount: result.maxPerTxAmount,
-    maxRebalanceAmount: result.maxRebalanceAmount,
-    spendingLimits: result.spendingLimits.map((sl) => ({
-      amount: sl.amount,
-      maxCount: sl.maxCount,
-      windowSeconds: sl.windowSeconds
-    })),
-    aiTriggerThreshold: result.aiTriggerThreshold,
-    requireAiVerification: result.requireAiVerification
-  };
-}
-async function isBotActive(publicClient, vaultAddress, botAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "isBotActive",
-    args: [botAddress]
-  });
-}
-async function getOperatorCeilings(publicClient, vaultAddress) {
-  const result = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "operatorCeilings"
-  });
-  const [maxPerTxAmount, maxBotDailyLimit, maxOperatorBots, vaultDailyAggregate, minAiTriggerFloor] = result;
-  return {
-    maxPerTxAmount,
-    maxBotDailyLimit,
-    maxOperatorBots,
-    vaultDailyAggregate,
-    minAiTriggerFloor
-  };
-}
-async function operatorMaxDrainPerDay(publicClient, vaultAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "operatorMaxDrainPerDay"
-  });
-}
-async function isVaultPaused(publicClient, vaultAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "paused"
-  });
-}
-async function getDomainSeparator(publicClient, vaultAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "DOMAIN_SEPARATOR"
-  });
-}
-async function getVaultVersion(publicClient, vaultAddress) {
-  const version = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "VERSION"
-  });
-  return Number(version);
-}
-async function getVaultOwner(publicClient, vaultAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "owner"
-  });
-}
-async function getVaultOperator(publicClient, vaultAddress) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "operator"
-  });
-}
-async function isDestinationAllowed(publicClient, vaultAddress, botAddress, destination) {
-  const isBlacklisted = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "globalDestinationBlacklist",
-    args: [destination]
-  });
-  if (isBlacklisted) {
-    return { allowed: false, reason: "Destination is on the global blacklist" };
-  }
-  const globalCount = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "globalDestinationCount"
-  });
-  if (globalCount > 0n) {
-    const isGlobalWhitelisted = await publicClient.readContract({
-      address: vaultAddress,
-      abi: AxonVaultAbi,
-      functionName: "globalDestinationWhitelist",
-      args: [destination]
-    });
-    if (!isGlobalWhitelisted) {
-      return { allowed: false, reason: "Destination is not on the global whitelist" };
-    }
-  }
-  const botCount = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "botDestinationCount",
-    args: [botAddress]
-  });
-  if (botCount > 0n) {
-    const isBotWhitelisted = await publicClient.readContract({
-      address: vaultAddress,
-      abi: AxonVaultAbi,
-      functionName: "botDestinationWhitelist",
-      args: [botAddress, destination]
-    });
-    if (!isBotWhitelisted) {
-      return { allowed: false, reason: "Destination is not on the bot whitelist" };
-    }
-  }
-  return { allowed: true };
-}
-async function getRebalanceTokenCount(publicClient, vaultAddress) {
-  const count = await publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "rebalanceTokenCount"
-  });
-  return Number(count);
-}
-async function isRebalanceTokenWhitelisted(publicClient, vaultAddress, token) {
-  return publicClient.readContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "rebalanceTokenWhitelist",
-    args: [token]
-  });
-}
-async function deployVault(walletClient, publicClient, relayerUrl) {
-  if (!walletClient.account) {
-    throw new Error("walletClient has no account attached");
-  }
-  const chainId = walletClient.chain?.id;
-  if (!chainId) throw new Error("walletClient has no chain configured");
-  const factoryAddress = await getFactoryAddress(chainId, relayerUrl);
-  const hash = await walletClient.writeContract({
-    address: factoryAddress,
-    abi: AxonVaultFactoryAbi,
-    functionName: "deployVault",
-    args: [],
-    account: walletClient.account,
-    chain: walletClient.chain ?? null
-  });
-  const receipt = await publicClient.waitForTransactionReceipt({ hash });
-  for (const log of receipt.logs) {
-    try {
-      if (log.topics.length >= 3 && log.topics[2]) {
-        const vaultAddress = `0x${log.topics[2].slice(26)}`;
-        return vaultAddress;
-      }
-    } catch {
-    }
-  }
-  throw new Error("VaultDeployed event not found in transaction receipt");
-}
-async function addBot(walletClient, publicClient, vaultAddress, botAddress, config) {
-  if (!walletClient.account) {
-    throw new Error("walletClient has no account attached");
-  }
-  const params = toBotConfigParams(config);
-  const hash = await walletClient.writeContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "addBot",
-    args: [botAddress, params],
-    account: walletClient.account,
-    chain: walletClient.chain ?? null
-  });
-  await publicClient.waitForTransactionReceipt({ hash });
-  return hash;
-}
-async function updateBotConfig(walletClient, publicClient, vaultAddress, botAddress, config) {
-  if (!walletClient.account) {
-    throw new Error("walletClient has no account attached");
-  }
-  const params = toBotConfigParams(config);
-  const hash = await walletClient.writeContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "updateBotConfig",
-    args: [botAddress, params],
-    account: walletClient.account,
-    chain: walletClient.chain ?? null
-  });
-  await publicClient.waitForTransactionReceipt({ hash });
-  return hash;
-}
-async function removeBot(walletClient, publicClient, vaultAddress, botAddress) {
-  if (!walletClient.account) {
-    throw new Error("walletClient has no account attached");
-  }
-  const hash = await walletClient.writeContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "removeBot",
-    args: [botAddress],
-    account: walletClient.account,
-    chain: walletClient.chain ?? null
-  });
-  await publicClient.waitForTransactionReceipt({ hash });
-  return hash;
-}
-async function deposit(walletClient, publicClient, vaultAddress, token, amount, ref = "0x0000000000000000000000000000000000000000000000000000000000000000") {
-  if (!walletClient.account) {
-    throw new Error("walletClient has no account attached");
-  }
-  const isEth = token.toLowerCase() === NATIVE_ETH.toLowerCase();
-  if (!isEth) {
-    const approveTx = await walletClient.writeContract({
-      address: token,
-      abi: erc20Abi,
-      functionName: "approve",
-      args: [vaultAddress, amount],
-      account: walletClient.account,
-      chain: walletClient.chain ?? null
-    });
-    await publicClient.waitForTransactionReceipt({ hash: approveTx });
-  }
-  const hash = await walletClient.writeContract({
-    address: vaultAddress,
-    abi: AxonVaultAbi,
-    functionName: "deposit",
-    args: [token, amount, ref],
-    account: walletClient.account,
-    chain: walletClient.chain ?? null,
-    ...isEth ? { value: amount } : {}
-  });
-  await publicClient.waitForTransactionReceipt({ hash });
-  return hash;
-}
 
 // src/tokens.ts
 var Token = /* @__PURE__ */ ((Token2) => {
@@ -3055,99 +2747,430 @@ var KNOWN_TOKENS = {
       42161: "0xfc5A1A6EB076a2C7aD06eD22C90d7E710E35ad0a"
     }
   }
-};
-var DEFAULT_APPROVED_TOKENS = [
-  "USDC",
-  "USDT",
-  "DAI",
-  "WETH",
-  "WBTC",
-  "cbBTC",
-  "wstETH",
-  "weETH",
-  "cbETH",
-  "rETH"
-];
-function getDefaultApprovedTokens(chainId) {
-  const addresses = [];
-  for (const symbol of DEFAULT_APPROVED_TOKENS) {
-    const entry = KNOWN_TOKENS[symbol];
-    const addr = entry.addresses[chainId];
-    if (addr) addresses.push(addr);
+};
+var DEFAULT_APPROVED_TOKENS = [
+  "USDC",
+  "USDT",
+  "DAI",
+  "WETH",
+  "WBTC",
+  "cbBTC",
+  "wstETH",
+  "weETH",
+  "cbETH",
+  "rETH"
+];
+function getDefaultApprovedTokens(chainId) {
+  const addresses = [];
+  for (const symbol of DEFAULT_APPROVED_TOKENS) {
+    const entry = KNOWN_TOKENS[symbol];
+    const addr = entry.addresses[chainId];
+    if (addr) addresses.push(addr);
+  }
+  return addresses;
+}
+var addressToSymbol = /* @__PURE__ */ new Map();
+for (const token of Object.values(KNOWN_TOKENS)) {
+  for (const addr of Object.values(token.addresses)) {
+    addressToSymbol.set(addr.toLowerCase(), token.symbol);
+  }
+}
+function getKnownTokensForChain(chainId) {
+  const result = [];
+  for (const token of Object.values(KNOWN_TOKENS)) {
+    const addr = token.addresses[chainId];
+    if (addr) {
+      result.push({ ...token, address: addr });
+    }
+  }
+  return result;
+}
+function getTokenSymbolByAddress(address) {
+  return addressToSymbol.get(address.toLowerCase()) ?? null;
+}
+function resolveToken(token, chainId) {
+  if (typeof token === "string" && token.startsWith("0x")) {
+    if (token === "0x0000000000000000000000000000000000000000") {
+      throw new Error("Token address cannot be the zero address");
+    }
+    return token;
+  }
+  const entry = KNOWN_TOKENS[token];
+  if (!entry) {
+    throw new Error(`Unknown token symbol: ${token}`);
+  }
+  const addr = entry.addresses[chainId];
+  if (!addr) {
+    throw new Error(`Token ${token} is not available on chain ${chainId}`);
+  }
+  return addr;
+}
+
+// src/amounts.ts
+function resolveTokenDecimals(token, chainId) {
+  if (typeof token === "string" && token.startsWith("0x")) {
+    const symbol = getTokenSymbolByAddress(token);
+    if (!symbol) {
+      throw new Error(
+        `Unknown token address ${token} \u2014 cannot determine decimals. Use a bigint amount instead, or pass a known token symbol.`
+      );
+    }
+    const entry2 = KNOWN_TOKENS[symbol];
+    return entry2.decimals;
+  }
+  const entry = KNOWN_TOKENS[token];
+  if (!entry) {
+    throw new Error(
+      `Unknown token symbol "${token}" \u2014 cannot determine decimals. Use a bigint amount instead, or use a known symbol (${Object.keys(KNOWN_TOKENS).join(", ")}).`
+    );
+  }
+  return entry.decimals;
+}
+function parseAmount(amount, token, chainId) {
+  if (typeof amount === "bigint") {
+    return amount;
+  }
+  const decimals = resolveTokenDecimals(token);
+  const str = typeof amount === "number" ? amount.toString() : amount;
+  const dotIndex = str.indexOf(".");
+  if (dotIndex !== -1) {
+    const decimalPlaces = str.length - dotIndex - 1;
+    if (decimalPlaces > decimals) {
+      throw new Error(
+        `Amount "${str}" has ${decimalPlaces} decimal places, but ${typeof token === "string" && token.startsWith("0x") ? "this token" : token} only supports ${decimals}. Truncate or round your amount.`
+      );
+    }
+  }
+  return parseUnits(str, decimals);
+}
+
+// src/vault.ts
+function getChain(chainId) {
+  switch (chainId) {
+    case 8453:
+      return base;
+    case 84532:
+      return baseSepolia;
+    case 42161:
+      return arbitrum;
+    case 421614:
+      return arbitrumSepolia;
+    default:
+      throw new Error(
+        `Unsupported chainId: ${chainId}. Supported: 8453 (Base), 84532 (Base Sepolia), 42161 (Arbitrum), 421614 (Arbitrum Sepolia)`
+      );
+  }
+}
+function createAxonPublicClient(chainId, rpcUrl) {
+  return createPublicClient({
+    chain: getChain(chainId),
+    transport: http(rpcUrl)
+  });
+}
+function createAxonWalletClient(privateKey, chainId) {
+  const account = privateKeyToAccount(privateKey);
+  return createWalletClient({
+    account,
+    chain: getChain(chainId),
+    transport: http()
+    // signing is local — transport is unused but required by viem
+  });
+}
+var USDC_DECIMALS = 6n;
+var USDC_UNIT = 10n ** USDC_DECIMALS;
+function toBotConfigParams(input) {
+  return {
+    maxPerTxAmount: BigInt(Math.round(input.maxPerTxAmount * Number(USDC_UNIT))),
+    maxRebalanceAmount: BigInt(Math.round(input.maxRebalanceAmount * Number(USDC_UNIT))),
+    spendingLimits: input.spendingLimits.map((sl) => ({
+      amount: BigInt(Math.round(sl.amount * Number(USDC_UNIT))),
+      maxCount: BigInt(sl.maxCount),
+      windowSeconds: BigInt(sl.windowSeconds)
+    })),
+    aiTriggerThreshold: BigInt(Math.round(input.aiTriggerThreshold * Number(USDC_UNIT))),
+    requireAiVerification: input.requireAiVerification
+  };
+}
+var DEFAULT_RELAYER_URL = "https://relay.axonfi.xyz";
+async function getFactoryAddress(chainId, relayerUrl) {
+  const base2 = relayerUrl ?? DEFAULT_RELAYER_URL;
+  const resp = await fetch(`${base2}/v1/chains`);
+  if (!resp.ok) throw new Error(`Failed to fetch chain config from relayer [${resp.status}]`);
+  const data = await resp.json();
+  const chain = data.chains?.find((c) => c.chainId === chainId);
+  if (!chain?.factoryAddress) {
+    throw new Error(`No factory address available for chainId ${chainId}. Check the relayer's chain configuration.`);
+  }
+  return chain.factoryAddress;
+}
+async function getBotConfig(publicClient, vaultAddress, botAddress) {
+  const result = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "getBotConfig",
+    args: [botAddress]
+  });
+  return {
+    isActive: result.isActive,
+    registeredAt: result.registeredAt,
+    maxPerTxAmount: result.maxPerTxAmount,
+    maxRebalanceAmount: result.maxRebalanceAmount,
+    spendingLimits: result.spendingLimits.map((sl) => ({
+      amount: sl.amount,
+      maxCount: sl.maxCount,
+      windowSeconds: sl.windowSeconds
+    })),
+    aiTriggerThreshold: result.aiTriggerThreshold,
+    requireAiVerification: result.requireAiVerification
+  };
+}
+async function isBotActive(publicClient, vaultAddress, botAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "isBotActive",
+    args: [botAddress]
+  });
+}
+async function getOperatorCeilings(publicClient, vaultAddress) {
+  const result = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operatorCeilings"
+  });
+  const [maxPerTxAmount, maxBotDailyLimit, maxOperatorBots, vaultDailyAggregate, minAiTriggerFloor] = result;
+  return {
+    maxPerTxAmount,
+    maxBotDailyLimit,
+    maxOperatorBots,
+    vaultDailyAggregate,
+    minAiTriggerFloor
+  };
+}
+async function operatorMaxDrainPerDay(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operatorMaxDrainPerDay"
+  });
+}
+async function isVaultPaused(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "paused"
+  });
+}
+async function getDomainSeparator(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "DOMAIN_SEPARATOR"
+  });
+}
+async function getVaultVersion(publicClient, vaultAddress) {
+  const version = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "VERSION"
+  });
+  return Number(version);
+}
+async function getVaultOwner(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "owner"
+  });
+}
+async function getVaultOperator(publicClient, vaultAddress) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "operator"
+  });
+}
+async function isDestinationAllowed(publicClient, vaultAddress, botAddress, destination) {
+  const isBlacklisted = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "globalDestinationBlacklist",
+    args: [destination]
+  });
+  if (isBlacklisted) {
+    return { allowed: false, reason: "Destination is on the global blacklist" };
+  }
+  const globalCount = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "globalDestinationCount"
+  });
+  if (globalCount > 0n) {
+    const isGlobalWhitelisted = await publicClient.readContract({
+      address: vaultAddress,
+      abi: AxonVaultAbi,
+      functionName: "globalDestinationWhitelist",
+      args: [destination]
+    });
+    if (!isGlobalWhitelisted) {
+      return { allowed: false, reason: "Destination is not on the global whitelist" };
+    }
+  }
+  const botCount = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "botDestinationCount",
+    args: [botAddress]
+  });
+  if (botCount > 0n) {
+    const isBotWhitelisted = await publicClient.readContract({
+      address: vaultAddress,
+      abi: AxonVaultAbi,
+      functionName: "botDestinationWhitelist",
+      args: [botAddress, destination]
+    });
+    if (!isBotWhitelisted) {
+      return { allowed: false, reason: "Destination is not on the bot whitelist" };
+    }
   }
-  return addresses;
+  return { allowed: true };
 }
-var addressToSymbol = /* @__PURE__ */ new Map();
-for (const token of Object.values(KNOWN_TOKENS)) {
-  for (const addr of Object.values(token.addresses)) {
-    addressToSymbol.set(addr.toLowerCase(), token.symbol);
-  }
+async function getRebalanceTokenCount(publicClient, vaultAddress) {
+  const count = await publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "rebalanceTokenCount"
+  });
+  return Number(count);
 }
-function getKnownTokensForChain(chainId) {
-  const result = [];
-  for (const token of Object.values(KNOWN_TOKENS)) {
-    const addr = token.addresses[chainId];
-    if (addr) {
-      result.push({ ...token, address: addr });
+async function isRebalanceTokenWhitelisted(publicClient, vaultAddress, token) {
+  return publicClient.readContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "rebalanceTokenWhitelist",
+    args: [token]
+  });
+}
+async function deployVault(walletClient, publicClient, relayerUrl) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
+  }
+  const chainId = walletClient.chain?.id;
+  if (!chainId) throw new Error("walletClient has no chain configured");
+  const factoryAddress = await getFactoryAddress(chainId, relayerUrl);
+  const hash = await walletClient.writeContract({
+    address: factoryAddress,
+    abi: AxonVaultFactoryAbi,
+    functionName: "deployVault",
+    args: [],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  const receipt = await publicClient.waitForTransactionReceipt({ hash });
+  for (const log of receipt.logs) {
+    try {
+      if (log.topics.length >= 3 && log.topics[2]) {
+        const vaultAddress = `0x${log.topics[2].slice(26)}`;
+        return vaultAddress;
+      }
+    } catch {
     }
   }
-  return result;
-}
-function getTokenSymbolByAddress(address) {
-  return addressToSymbol.get(address.toLowerCase()) ?? null;
+  throw new Error("VaultDeployed event not found in transaction receipt");
 }
-function resolveToken(token, chainId) {
-  if (typeof token === "string" && token.startsWith("0x")) {
-    if (token === "0x0000000000000000000000000000000000000000") {
-      throw new Error("Token address cannot be the zero address");
-    }
-    return token;
+async function addBot(walletClient, publicClient, vaultAddress, botAddress, config) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
   }
-  const entry = KNOWN_TOKENS[token];
-  if (!entry) {
-    throw new Error(`Unknown token symbol: ${token}`);
+  const params = toBotConfigParams(config);
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "addBot",
+    args: [botAddress, params],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function updateBotConfig(walletClient, publicClient, vaultAddress, botAddress, config) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
   }
-  const addr = entry.addresses[chainId];
-  if (!addr) {
-    throw new Error(`Token ${token} is not available on chain ${chainId}`);
+  const params = toBotConfigParams(config);
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "updateBotConfig",
+    args: [botAddress, params],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
+}
+async function removeBot(walletClient, publicClient, vaultAddress, botAddress) {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
   }
-  return addr;
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "removeBot",
+    args: [botAddress],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
 }
-function resolveTokenDecimals(token, chainId) {
-  if (typeof token === "string" && token.startsWith("0x")) {
-    const symbol = getTokenSymbolByAddress(token);
-    if (!symbol) {
-      throw new Error(
-        `Unknown token address ${token} \u2014 cannot determine decimals. Use a bigint amount instead, or pass a known token symbol.`
-      );
-    }
-    const entry2 = KNOWN_TOKENS[symbol];
-    return entry2.decimals;
+async function deposit(walletClient, publicClient, vaultAddress, token, amount, ref = "0x0000000000000000000000000000000000000000000000000000000000000000") {
+  if (!walletClient.account) {
+    throw new Error("walletClient has no account attached");
   }
-  const entry = KNOWN_TOKENS[token];
-  if (!entry) {
-    throw new Error(
-      `Unknown token symbol "${token}" \u2014 cannot determine decimals. Use a bigint amount instead, or use a known symbol (${Object.keys(KNOWN_TOKENS).join(", ")}).`
-    );
+  const isEthSymbol = token === "ETH" || token === "eth";
+  let tokenAddress;
+  if (isEthSymbol) {
+    tokenAddress = NATIVE_ETH;
+  } else if (token.startsWith("0x")) {
+    tokenAddress = token;
+  } else {
+    const chainId = walletClient.chain?.id;
+    if (!chainId) throw new Error("walletClient has no chain \u2014 cannot resolve token symbol");
+    tokenAddress = resolveToken(token, chainId);
   }
-  return entry.decimals;
-}
-function parseAmount(amount, token, chainId) {
+  const isEth = tokenAddress.toLowerCase() === NATIVE_ETH.toLowerCase();
+  let resolvedAmount;
   if (typeof amount === "bigint") {
-    return amount;
+    resolvedAmount = amount;
+  } else if (isEth) {
+    resolvedAmount = parseAmount(amount, "WETH");
+  } else {
+    resolvedAmount = parseAmount(amount, token);
   }
-  const decimals = resolveTokenDecimals(token);
-  const str = typeof amount === "number" ? amount.toString() : amount;
-  const dotIndex = str.indexOf(".");
-  if (dotIndex !== -1) {
-    const decimalPlaces = str.length - dotIndex - 1;
-    if (decimalPlaces > decimals) {
-      throw new Error(
-        `Amount "${str}" has ${decimalPlaces} decimal places, but ${typeof token === "string" && token.startsWith("0x") ? "this token" : token} only supports ${decimals}. Truncate or round your amount.`
-      );
-    }
+  if (!isEth) {
+    const approveTx = await walletClient.writeContract({
+      address: tokenAddress,
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [vaultAddress, resolvedAmount],
+      account: walletClient.account,
+      chain: walletClient.chain ?? null
+    });
+    await publicClient.waitForTransactionReceipt({ hash: approveTx });
   }
-  return parseUnits(str, decimals);
+  const hash = await walletClient.writeContract({
+    address: vaultAddress,
+    abi: AxonVaultAbi,
+    functionName: "deposit",
+    args: [tokenAddress, resolvedAmount, ref],
+    account: walletClient.account,
+    chain: walletClient.chain ?? null,
+    ...isEth ? { value: resolvedAmount } : {}
+  });
+  await publicClient.waitForTransactionReceipt({ hash });
+  return hash;
 }
 
 // src/utils.ts