@trustwallet/cli 0.14.0 → 0.15.0

package/dist/index.js

@@ -3123,6 +3123,8 @@ __export(dist_exports, {
   COMMON_TOKENS: () => COMMON_TOKENS,
   CommandError: () => CommandError,
   ERC20_ERROR_CODES: () => ERC20_ERROR_CODES,
+  ERC20_TRANSFER_SIG: () => ERC20_TRANSFER_SIG,
+  EVM_ADDRESS_RE: () => EVM_ADDRESS_RE,
   Erc20Error: () => Erc20Error,
   McpResponse: () => McpResponse,
   NATIVE_TOKEN_ADDRESS: () => NATIVE_TOKEN_ADDRESS,
@@ -3144,6 +3146,7 @@ __export(dist_exports, {
   WatchError: () => WatchError,
   X402Error: () => X402Error,
   X402_ERROR_CODES: () => X402_ERROR_CODES,
+  assertEvmAddress: () => assertEvmAddress,
   assertStrictPositiveAmount: () => assertStrictPositiveAmount,
   chainKeyToCoinType: () => chainKeyToCoinType,
   classifyApiError: () => classifyApiError,
@@ -3151,6 +3154,7 @@ __export(dist_exports, {
   classifyWalletLoadError: () => classifyWalletLoadError,
   coinTypeToChainKey: () => coinTypeToChainKey,
   createTwakClient: () => createTwakClient,
+  encodeErc20Transfer: () => encodeErc20Transfer,
   fetchBalance: () => fetchBalance,
   fetchBalances: () => fetchBalances,
   fiatToTokenAmount: () => fiatToTokenAmount,
@@ -3169,13 +3173,18 @@ __export(dist_exports, {
   getSupportedCoinTypes: () => getSupportedCoinTypes,
   isChainSupported: () => isChainSupported,
   isCoinTypeSupported: () => isCoinTypeSupported,
+  isEvmAddress: () => isEvmAddress,
   isNativeTokenId: () => isNativeTokenId,
   isRateLimited: () => isRateLimited,
+  lookupKnownTokenDecimals: () => lookupKnownTokenDecimals,
   parseAmount: () => parseAmount,
   parseHumanAmount: () => parseHumanAmount,
   parseTokenId: () => parseTokenId,
   rankQuotesByBest: () => rankQuotesByBest,
+  requireChain: () => requireChain,
   resolveAddressOrName: () => resolveAddressOrName,
+  resolveAsset: () => resolveAsset,
+  resolveChain: () => resolveChain,
   resolveName: () => resolveName,
   resolveToken: () => resolveToken,
   signRequest: () => signRequest,
@@ -3234,20 +3243,30 @@ function getNativeAddressPlaceholder(chainKey) {
   if (chain2.id === "celo") return CELO_NATIVE_ADDRESS;
   return NATIVE_TOKEN_ADDRESS;
 }
+function lookupKnownTokenDecimals(chainKey, tokenAddress) {
+  const chain2 = getChainById(chainKey);
+  if (!chain2) return void 0;
+  if (!tokenAddress) return chain2.decimals;
+  const mapKey = getChainMapKey(chainKey) ?? chainKey.toLowerCase();
+  const registry = COMMON_TOKENS[mapKey] ?? {};
+  const entry = Object.values(registry).find(
+    (e2) => e2.address.toLowerCase() === tokenAddress.toLowerCase()
+  );
+  return entry?.decimals;
+}
 function resolveToken(token, chainKey) {
   const assetIdMatch = token.match(/^c(\d+)(?:_t(.+))?$/);
   if (assetIdMatch) {
     const coinId = parseInt(assetIdMatch[1]);
     const contractAddress = assetIdMatch[2];
-    const chain2 = Object.values(CHAINS).find((c3) => c3.coinId === coinId);
-    if (chain2) {
+    const found = Object.entries(CHAINS).find(([, c3]) => c3.coinId === coinId);
+    if (found) {
+      const [mapKey2, chain2] = found;
       if (contractAddress) {
-        const sym = Object.entries(COMMON_TOKENS[chain2.id] || {}).find(
-          ([, addr]) => addr.toLowerCase() === contractAddress.toLowerCase()
-        )?.[0]?.replace(".e", "");
-        const isBscChain = chain2.id === "smartchain";
-        const decimals = isBscChain && sym && BSC_18_DECIMAL_TOKENS.has(sym) ? 18 : TOKEN_DECIMALS[sym ?? ""] ?? 18;
-        return { address: contractAddress, decimals };
+        const entry = Object.values(COMMON_TOKENS[mapKey2] || {}).find(
+          (e2) => e2.address.toLowerCase() === contractAddress.toLowerCase()
+        );
+        return { address: contractAddress, decimals: entry?.decimals ?? 18 };
       }
       return {
         address: getNativeAddressPlaceholder(chain2.id),
@@ -3258,11 +3277,9 @@ function resolveToken(token, chainKey) {
   const upperToken = token.toUpperCase();
   const chainConfig = getChainById(chainKey);
   const mapKey = getChainMapKey(chainKey) ?? chainKey.toLowerCase();
-  const isBsc = mapKey === "bsc";
   const chainTokens = COMMON_TOKENS[mapKey];
   if (chainTokens?.[upperToken]) {
-    const decimals = isBsc && BSC_18_DECIMAL_TOKENS.has(upperToken) ? 18 : TOKEN_DECIMALS[upperToken] ?? 18;
-    return { address: chainTokens[upperToken], decimals };
+    return { address: chainTokens[upperToken].address, decimals: chainTokens[upperToken].decimals };
   }
   if (NATIVE_SYMBOLS.has(upperToken) || chainConfig && upperToken === chainConfig.symbol.toUpperCase()) {
     return {
@@ -3271,23 +3288,20 @@ function resolveToken(token, chainKey) {
     };
   }
   if (upperToken.startsWith("USDC")) {
-    const addr = chainTokens?.["USDC.e"] || chainTokens?.["USDC"];
-    if (!addr) return null;
-    return { address: addr, decimals: isBsc ? 18 : 6 };
+    const entry = chainTokens?.["USDC.e"] || chainTokens?.["USDC"];
+    if (!entry) return null;
+    return { address: entry.address, decimals: entry.decimals };
   }
   if (upperToken.startsWith("USDT")) {
-    const addr = chainTokens?.["USDT"];
-    if (!addr) return null;
-    return { address: addr, decimals: isBsc ? 18 : 6 };
+    const entry = chainTokens?.["USDT"];
+    if (!entry) return null;
+    return { address: entry.address, decimals: entry.decimals };
   }
   if (token.startsWith("0x") || token.length > 20) {
     for (const tokens of Object.values(COMMON_TOKENS)) {
-      for (const [symbol, addr] of Object.entries(tokens)) {
-        if (addr.toLowerCase() === token.toLowerCase()) {
-          return {
-            address: token,
-            decimals: TOKEN_DECIMALS[symbol.replace(".e", "")] ?? 18
-          };
+      for (const entry of Object.values(tokens)) {
+        if (entry.address.toLowerCase() === token.toLowerCase()) {
+          return { address: token, decimals: entry.decimals };
         }
       }
     }
@@ -3378,6 +3392,95 @@ function tryClassifyError(err) {
   }
   return classifyApiError(err) ?? classifyStorageError(err) ?? classifyWalletLoadError(err);
 }
+function formatTokenId(coinId, contractAddress) {
+  if (contractAddress) {
+    return `c${coinId}_t${contractAddress}`;
+  }
+  return `c${coinId}`;
+}
+function parseTokenId(id) {
+  const match = id.match(/^c(\d+)(?:_t(.+))?$/);
+  if (!match) {
+    throw new Error(`Invalid token ID format: ${id}`);
+  }
+  const coinId = Number(match[1]);
+  const contractAddress = match[2] || void 0;
+  return { coinId, contractAddress };
+}
+function isNativeTokenId(id) {
+  return /^c\d+$/.test(id);
+}
+function tokenIdToChain(id) {
+  const { coinId } = parseTokenId(id);
+  const chain2 = getChainByCoinId(coinId);
+  if (!chain2) return void 0;
+  return Object.entries(CHAINS).find(([, c3]) => c3.coinId === coinId)?.[0];
+}
+function resolveChain(input2) {
+  if (typeof input2 !== "string" || input2.trim().length === 0) {
+    throw new WalletError(
+      "CHAIN_UNSUPPORTED",
+      'Chain identifier is required. Examples: "ethereum", "bsc", "solana", "56", "eip155:8453".'
+    );
+  }
+  const lower = input2.trim().toLowerCase();
+  const colonIdx = lower.indexOf(":");
+  if (colonIdx > 0 && colonIdx < lower.length - 1) {
+    const namespace = lower.slice(0, colonIdx);
+    const reference = lower.slice(colonIdx + 1);
+    for (const [key, chain2] of Object.entries(CHAINS)) {
+      if (chain2.namespace === namespace && chain2.chainId.toLowerCase() === reference) {
+        return key;
+      }
+    }
+    throw chainUnsupported(input2);
+  }
+  if (lower.startsWith("c") && lower.length > 1) {
+    const rest = lower.slice(1);
+    const underscoreIdx = rest.indexOf("_");
+    const coinStr = underscoreIdx === -1 ? rest : rest.slice(0, underscoreIdx);
+    if (/^\d+$/.test(coinStr)) {
+      const key = coinTypeToChainKey(Number(coinStr));
+      if (key) return key;
+      throw chainUnsupported(input2);
+    }
+  }
+  if (CHAINS[lower]) return lower;
+  const aliased = ALIASES[lower];
+  if (aliased) return aliased;
+  for (const [key, chain2] of Object.entries(CHAINS)) {
+    if (chain2.id === lower) return key;
+  }
+  if (/^0x[0-9a-f]+$/.test(lower)) {
+    const key = lookupEvm(parseInt(lower, 16).toString());
+    if (key) return key;
+  } else if (/^\d+$/.test(lower)) {
+    const key = lookupEvm(lower);
+    if (key) return key;
+  }
+  throw chainUnsupported(input2);
+}
+function lookupEvm(chainId) {
+  for (const [key, chain2] of Object.entries(CHAINS)) {
+    if (chain2.namespace === "eip155" && chain2.chainId === chainId) return key;
+  }
+  return void 0;
+}
+function resolveAsset(chain2, tokenAddress) {
+  const chainKey = resolveChain(chain2);
+  const coinId = CHAINS[chainKey].coinId;
+  return { chainKey, coinId, assetId: formatTokenId(coinId, tokenAddress) };
+}
+function chainUnsupported(input2) {
+  const suggestions = suggest(input2);
+  const hint = suggestions.length > 0 ? ` Did you mean: ${suggestions.map((s2) => `"${s2}"`).join(", ")}?` : "";
+  return new WalletError("CHAIN_UNSUPPORTED", `Unknown chain: "${input2}".${hint}`);
+}
+function suggest(input2) {
+  const lower = input2.trim().toLowerCase();
+  const candidates = [...Object.keys(CHAINS), ...Object.keys(ALIASES)];
+  return candidates.filter((c3) => c3.includes(lower) || lower.includes(c3)).slice(0, 3);
+}
 function sortQueryParams(query) {
   if (!query) return query;
   const queryParams = new URLSearchParams(query);
@@ -3490,29 +3593,29 @@ async function resolveAddressOrName(value) {
   if (!resolved) throw new Error(`Could not resolve name: ${value}`);
   return resolved;
 }
-function formatTokenId(coinId, contractAddress) {
-  if (contractAddress) {
-    return `c${coinId}_t${contractAddress}`;
-  }
-  return `c${coinId}`;
+function isEvmAddress(value) {
+  return EVM_ADDRESS_RE.test(value);
 }
-function parseTokenId(id) {
-  const match = id.match(/^c(\d+)(?:_t(.+))?$/);
-  if (!match) {
-    throw new Error(`Invalid token ID format: ${id}`);
+function assertEvmAddress(value, label) {
+  if (!EVM_ADDRESS_RE.test(value)) {
+    throw new WalletError(
+      "VALIDATION_ERROR",
+      `${label} is not a valid EVM address: ${value}. Expected 0x-prefixed 40-hex.`
+    );
   }
-  const coinId = Number(match[1]);
-  const contractAddress = match[2] || void 0;
-  return { coinId, contractAddress };
 }
-function isNativeTokenId(id) {
-  return /^c\d+$/.test(id);
+function encodeErc20Transfer(to3, amount) {
+  assertEvmAddress(to3, "to");
+  const paddedTo = to3.slice(2).toLowerCase().padStart(64, "0");
+  const paddedAmount = amount.toString(16).padStart(64, "0");
+  return `${ERC20_TRANSFER_SIG}${paddedTo}${paddedAmount}`;
 }
-function tokenIdToChain(id) {
-  const { coinId } = parseTokenId(id);
-  const chain2 = getChainByCoinId(coinId);
-  if (!chain2) return void 0;
-  return Object.entries(CHAINS).find(([, c3]) => c3.coinId === coinId)?.[0];
+function requireChain(chainKey) {
+  const chain2 = getChainById(chainKey);
+  if (!chain2) {
+    throw new TwakValidationError(`Unknown chain: ${chainKey}`, { chainKey });
+  }
+  return chain2;
 }
 function sortQueryRaw(query) {
   if (!query) return query;
@@ -3614,7 +3717,7 @@ async function fetchBalance(httpClient, assetId, address, currency = "USD") {
     throw new BalanceError("NETWORK_ERROR", "Could not fetch balance. Please try again later.");
   }
 }
-var import_crypto, NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_ADDRESS, CHAINS, COMMON_TOKENS, BSC_18_DECIMAL_TOKENS, NATIVE_SYMBOLS, TOKEN_DECIMALS, CELO_NATIVE_ADDRESS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, FS_ERRNO_CODES, SWAP_ERROR_CODES, SwapError, TRANSFER_ERROR_CODES, TransferError, WALLET_ERROR_CODES, WalletError, QUERY_ERROR_CODES, QueryError, BALANCE_ERROR_CODES, BalanceError, ALERT_ERROR_CODES, AlertError, ERC20_ERROR_CODES, Erc20Error, WATCH_ERROR_CODES, WatchError, AUTOMATION_ERROR_CODES, AutomationError, X402_ERROR_CODES, X402Error, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, DEFAULT_GATEWAY_URL, DEFAULT_MARKET_URL, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, DEFAULT_X_ORIGIN, TwakHttpClient, ALLOWED_OFFRAMP_PROVIDERS, McpResponse;
+var import_crypto, NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_ADDRESS, CHAINS, COMMON_TOKENS, NATIVE_SYMBOLS, CELO_NATIVE_ADDRESS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, FS_ERRNO_CODES, SWAP_ERROR_CODES, SwapError, TRANSFER_ERROR_CODES, TransferError, WALLET_ERROR_CODES, WalletError, QUERY_ERROR_CODES, QueryError, BALANCE_ERROR_CODES, BalanceError, ALERT_ERROR_CODES, AlertError, ERC20_ERROR_CODES, Erc20Error, WATCH_ERROR_CODES, WatchError, AUTOMATION_ERROR_CODES, AutomationError, X402_ERROR_CODES, X402Error, ALIASES, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, EVM_ADDRESS_RE, ERC20_TRANSFER_SIG, DEFAULT_GATEWAY_URL, DEFAULT_MARKET_URL, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, DEFAULT_X_ORIGIN, TwakHttpClient, ALLOWED_OFFRAMP_PROVIDERS, McpResponse;
 var init_dist = __esm({
   "../core/dist/index.mjs"() {
     "use strict";
@@ -3646,7 +3749,10 @@ var init_dist = __esm({
         explorerUrl: "https://arbiscan.io",
         rpcUrl: "https://arbitrum.rpc.trustwallet.com",
         isEVM: true,
-        sampleAccount: "0xecf9ffa7f51e1194f89c25ad8c484f6bfd04e1ac"
+        sampleAccount: "0xecf9ffa7f51e1194f89c25ad8c484f6bfd04e1ac",
+        // Sub-second block times — poll fast, fail fast.
+        receiptPollMs: 500,
+        receiptTimeoutMs: 3e4
       },
       optimism: {
         id: "optimism",
@@ -3659,7 +3765,8 @@ var init_dist = __esm({
         explorerUrl: "https://optimistic.etherscan.io",
         rpcUrl: "https://optimism.rpc.trustwallet.com",
         isEVM: true,
-        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+        receiptPollMs: 1e3
       },
       polygon: {
         id: "polygon",
@@ -3672,7 +3779,8 @@ var init_dist = __esm({
         explorerUrl: "https://polygonscan.com",
         rpcUrl: "https://polygon.rpc.trustwallet.com",
         isEVM: true,
-        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+        receiptPollMs: 1e3
       },
       bsc: {
         id: "smartchain",
@@ -3698,7 +3806,8 @@ var init_dist = __esm({
         explorerUrl: "https://snowtrace.io",
         rpcUrl: "https://avalanche.rpc.trustwallet.com",
         isEVM: true,
-        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+        receiptPollMs: 1e3
       },
       base: {
         id: "base",
@@ -3711,7 +3820,8 @@ var init_dist = __esm({
         explorerUrl: "https://basescan.org",
         rpcUrl: "https://base.rpc.trustwallet.com",
         isEVM: true,
-        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
+        sampleAccount: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
+        receiptPollMs: 1e3
       },
       fantom: {
         id: "fantom",
@@ -3950,72 +4060,72 @@ var init_dist = __esm({
     };
     COMMON_TOKENS = {
       ethereum: {
-        USDT: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
-        USDC: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-        DAI: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-        WETH: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-        WBTC: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599"
+        USDT: { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6 },
+        USDC: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6 },
+        DAI: { address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", decimals: 18 },
+        WETH: { address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", decimals: 18 },
+        WBTC: { address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", decimals: 8 }
       },
       arbitrum: {
-        USDT: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
-        USDC: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
-        "USDC.e": "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
-        DAI: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
-        WETH: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
-        WBTC: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f",
-        ARB: "0x912CE59144191C1204E64559FE8253a0e49E6548"
+        USDT: { address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", decimals: 6 },
+        USDC: { address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", decimals: 6 },
+        "USDC.e": { address: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8", decimals: 6 },
+        DAI: { address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1", decimals: 18 },
+        WETH: { address: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", decimals: 18 },
+        WBTC: { address: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", decimals: 8 },
+        ARB: { address: "0x912CE59144191C1204E64559FE8253a0e49E6548", decimals: 18 }
       },
       polygon: {
-        USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
-        USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
-        "USDC.e": "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
-        DAI: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",
-        WMATIC: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
-        WETH: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619"
+        USDT: { address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", decimals: 6 },
+        USDC: { address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", decimals: 6 },
+        "USDC.e": { address: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", decimals: 6 },
+        DAI: { address: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063", decimals: 18 },
+        WMATIC: { address: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270", decimals: 18 },
+        WETH: { address: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619", decimals: 18 }
       },
       bsc: {
-        USDT: "0x55d398326f99059fF775485246999027B3197955",
-        USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
-        BUSD: "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
-        DAI: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3",
-        WBNB: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
-        ETH: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8",
-        TWT: "0x4B0F1812e5Df2A09796481Ff14017e6005508003"
+        // BEP-20 stables on BSC use 18 decimals (vs the canonical 6 on Ethereum).
+        USDT: { address: "0x55d398326f99059fF775485246999027B3197955", decimals: 18 },
+        USDC: { address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", decimals: 18 },
+        BUSD: { address: "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56", decimals: 18 },
+        DAI: { address: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3", decimals: 18 },
+        WBNB: { address: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", decimals: 18 },
+        ETH: { address: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", decimals: 18 },
+        TWT: { address: "0x4B0F1812e5Df2A09796481Ff14017e6005508003", decimals: 18 }
       },
       base: {
-        USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-        USDbC: "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",
-        DAI: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb",
-        WETH: "0x4200000000000000000000000000000000000006"
+        USDC: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6 },
+        USDbC: { address: "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA", decimals: 6 },
+        DAI: { address: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb", decimals: 18 },
+        WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18 }
       },
       avalanche: {
-        USDT: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7",
-        USDC: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
-        "USDC.e": "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664",
-        DAI: "0xd586E7F844cEa2F87f50152665BCbc2C279D8d70",
-        WAVAX: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7"
+        USDT: { address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7", decimals: 6 },
+        USDC: { address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", decimals: 6 },
+        "USDC.e": { address: "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664", decimals: 6 },
+        DAI: { address: "0xd586E7F844cEa2F87f50152665BCbc2C279D8d70", decimals: 18 },
+        WAVAX: { address: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7", decimals: 18 }
       },
       optimism: {
-        USDT: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58",
-        USDC: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
-        "USDC.e": "0x7F5c764cBc14f9669B88837ca1490cCa17c31607",
-        DAI: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1",
-        WETH: "0x4200000000000000000000000000000000000006",
-        OP: "0x4200000000000000000000000000000000000042"
+        USDT: { address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58", decimals: 6 },
+        USDC: { address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85", decimals: 6 },
+        "USDC.e": { address: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607", decimals: 6 },
+        DAI: { address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1", decimals: 18 },
+        WETH: { address: "0x4200000000000000000000000000000000000006", decimals: 18 },
+        OP: { address: "0x4200000000000000000000000000000000000042", decimals: 18 }
       },
       tron: {
-        USDT: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
-        USDC: "TEkxiTehnzSmSe2XqrBj4w32RUN966rdz8"
+        USDT: { address: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t", decimals: 6 },
+        USDC: { address: "TEkxiTehnzSmSe2XqrBj4w32RUN966rdz8", decimals: 6 }
       },
       solana: {
-        USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-        USDT: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
-        BONK: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263",
-        JUP: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN",
-        WSOL: "So11111111111111111111111111111111111111112"
+        USDC: { address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", decimals: 6 },
+        USDT: { address: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB", decimals: 6 },
+        BONK: { address: "DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263", decimals: 5 },
+        JUP: { address: "JUPyiwrYJFskUPiHa7hkeR8VUtAeFoSYbKedZNsDvCN", decimals: 6 },
+        WSOL: { address: "So11111111111111111111111111111111111111112", decimals: 9 }
       }
     };
-    BSC_18_DECIMAL_TOKENS = /* @__PURE__ */ new Set(["USDT", "USDC", "BUSD"]);
     NATIVE_SYMBOLS = /* @__PURE__ */ new Set([
       "NATIVE",
       "ETH",
@@ -4045,41 +4155,6 @@ var init_dist = __esm({
       "DOGE"
       // Bitcoin family
     ]);
-    TOKEN_DECIMALS = {
-      USDC: 6,
-      USDT: 6,
-      BUSD: 6,
-      DAI: 18,
-      ETH: 18,
-      MATIC: 18,
-      BNB: 18,
-      AVAX: 18,
-      FTM: 18,
-      SOL: 9,
-      S: 18,
-      CELO: 18,
-      WETH: 18,
-      WMATIC: 18,
-      WBNB: 18,
-      WAVAX: 18,
-      WBTC: 8,
-      ARB: 18,
-      OP: 18,
-      // Non-EVM natives
-      TRX: 6,
-      APT: 8,
-      TON: 9,
-      SUI: 9,
-      NEAR: 24,
-      ATOM: 6,
-      BTC: 8,
-      LTC: 8,
-      DOGE: 8,
-      // Solana SPL tokens
-      BONK: 5,
-      JUP: 6,
-      WSOL: 9
-    };
     CELO_NATIVE_ADDRESS = "0x471EcE3750Da237f93B8E339c536989b8978a438";
     TwakError = class extends Error {
       constructor(message, code2, details) {
@@ -4266,9 +4341,17 @@ var init_dist = __esm({
         this.name = "X402Error";
       }
     };
+    ALIASES = {
+      "binance-smart-chain": "bsc",
+      matic: "polygon",
+      "arbitrum-one": "arbitrum",
+      op: "optimism"
+    };
     DECIMAL_AMOUNT_RE = /^(?:0|[1-9]\d*)(?:\.\d+)?$/;
     UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
     NAMING_API = "https://naming.trustwallet.com/v1/lookup";
+    EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
+    ERC20_TRANSFER_SIG = "0xa9059cbb";
     DEFAULT_GATEWAY_URL = "https://tws.trustwallet.com";
     DEFAULT_MARKET_URL = "https://market.trustwallet.com";
     DEFAULT_TIMEOUT = 3e4;
@@ -4430,7 +4513,7 @@ function getPassword(service, account) {
     throw err;
   }
 }
-var fs, path, os, crypto2, crypto22, import_keyring, crypto3, crypto4, FileStore, ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, ITERATIONS, SERVICE, WALLET_ACCOUNT, API_SECRET_ACCOUNT, PROBE_ACCOUNT, KeychainManager, CREDENTIALS_FILE, CredentialManager, WALLET_FILE, WalletConfigStore, ALERTS_FILE, AlertStore, AUTOMATIONS_FILE, AutomationStore, SEEN_HASHES_FILE, SeenHashStore, ASSET_CACHE_FILE, AssetCache;
+var fs, path, os, crypto2, crypto22, import_keyring, crypto3, crypto4, FileStore, ALGORITHM, KEY_LENGTH, IV_LENGTH, SALT_LENGTH, ITERATIONS, SERVICE, WALLET_ACCOUNT, API_SECRET_ACCOUNT, PROBE_ACCOUNT, KeychainManager, CREDENTIALS_FILE, CredentialManager, WALLET_FILE, WalletConfigStore, ALERTS_FILE, AlertStore, AUTOMATIONS_FILE, AutomationStore, ASSET_CACHE_FILE, AssetCache;
 var init_dist2 = __esm({
   "../storage/dist/index.mjs"() {
     "use strict";
@@ -4731,34 +4814,6 @@ var init_dist2 = __esm({
         return automations.filter((a3) => a3.active);
       }
     };
-    SEEN_HASHES_FILE = "seen-hashes.json";
-    SeenHashStore = class {
-      store;
-      // In-memory cache prevents duplicate acceptance within the same process
-      memCache = /* @__PURE__ */ new Set();
-      constructor(config) {
-        this.store = new FileStore(config);
-      }
-      async hasSeen(txHash) {
-        const normalized = txHash.toLowerCase();
-        if (this.memCache.has(normalized)) return true;
-        const records = await this.list();
-        return records.some((r3) => r3.txHash === normalized);
-      }
-      async markSeen(txHash, chainId) {
-        const normalized = txHash.toLowerCase();
-        this.memCache.add(normalized);
-        const records = await this.list();
-        records.push({ txHash: normalized, chainId, usedAt: (/* @__PURE__ */ new Date()).toISOString() });
-        await this.store.write(SEEN_HASHES_FILE, records);
-      }
-      async list() {
-        return await this.store.read(SEEN_HASHES_FILE) || [];
-      }
-      async clear() {
-        await this.store.remove(SEEN_HASHES_FILE);
-      }
-    };
     ASSET_CACHE_FILE = "asset-cache.json";
     AssetCache = class {
       store;
@@ -6352,6 +6407,34 @@ var require_source = __commonJS({
 });
 
 // ../wallet-core/dist/index.mjs
+var dist_exports2 = {};
+__export(dist_exports2, {
+  AgentWalletProvider: () => AgentWalletProvider,
+  BlockchainClient: () => BlockchainClient,
+  TeeWalletProvider: () => TeeWalletProvider,
+  VerifyCredentialsError: () => VerifyCredentialsError,
+  WalletContext: () => WalletContext,
+  WalletCoreSigner: () => WalletCoreSigner,
+  WalletProvider: () => WalletProvider,
+  _setWalletCore: () => _setWalletCore,
+  applyPolyfills: () => applyPolyfills,
+  buildCoinTypeMap: () => buildCoinTypeMap,
+  chainKeyToDefinedChain: () => chainKeyToDefinedChain,
+  createPendingTransaction: () => createPendingTransaction,
+  getAmberDomainsByCoinId: () => getAmberDomainsByCoinId,
+  getCoinType: () => getCoinType,
+  getWalletCore: () => getWalletCore,
+  humanAmountToWei: () => humanAmountToWei,
+  initTrustSDK: () => initTrustSDK,
+  isInitialized: () => isInitialized,
+  patchNaasSession: () => patchNaasSession,
+  patchNodeStubs: () => patchNodeStubs,
+  registerDeviceAndWallet: () => registerDeviceAndWallet,
+  registerShutdownHandlers: () => registerShutdownHandlers,
+  setPolyfillCredentials: () => setPolyfillCredentials,
+  setPolyfillNaasSessionId: () => setPolyfillNaasSessionId,
+  verifyCredentials: () => verifyCredentials
+});
 function setPolyfillCredentials(creds) {
   _credentials = creds;
 }
@@ -6590,41 +6673,60 @@ function patchNodeStubs() {
     } catch {
     }
     if (parsedUrl?.hostname === "tws.trustwallet.com" && parsedUrl.pathname === "/v2/devices/fingerprint") {
-      return Promise.resolve(new Response(JSON.stringify({
-        device_id: _credentials?.accessId || "twak-cli",
-        hash_key: _credentials?.hmacSecret || ""
-      }), {
-        status: 200,
-        headers: { "content-type": "application/json" }
-      }));
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            device_id: _credentials?.accessId || "twak-cli",
+            hash_key: _credentials?.hmacSecret || ""
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" }
+          }
+        )
+      );
     }
     if (url.includes("/v2/projects/") && url.includes("/nodes")) {
-      return Promise.resolve(new Response(JSON.stringify({
-        message: "ok",
-        code: 200,
-        data: [
-          { network: "solana", name: "solana", nodes: [{ url: "https://solana.twnodes.com", weight: "high" }] }
-        ]
-      }), {
-        status: 200,
-        headers: { "content-type": "application/json" }
-      }));
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            message: "ok",
+            code: 200,
+            data: [
+              {
+                network: "solana",
+                name: "solana",
+                nodes: [{ url: "https://solana.twnodes.com", weight: "high" }]
+              }
+            ]
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" }
+          }
+        )
+      );
     }
     if (url.includes("/btc-indexer/inscribed/") && url.includes("/available-balance")) {
       const addrMatch = url.match(/\/address\/([^/]+)\//);
       const addr = addrMatch?.[1] ?? "";
-      return Promise.resolve(new Response(JSON.stringify({
-        address: addr,
-        balance: "0",
-        totalReceived: "0",
-        totalSent: "0",
-        unconfirmedBalance: "0",
-        unconfirmedTxs: 0,
-        txs: 0
-      }), {
-        status: 200,
-        headers: { "content-type": "application/json" }
-      }));
+      return Promise.resolve(
+        new Response(
+          JSON.stringify({
+            address: addr,
+            balance: "0",
+            totalReceived: "0",
+            totalSent: "0",
+            unconfirmedBalance: "0",
+            unconfirmedTxs: 0,
+            txs: 0
+          }),
+          {
+            status: 200,
+            headers: { "content-type": "application/json" }
+          }
+        )
+      );
     }
     let resolvedUrl = url;
     if (_naasSessionId && url.includes(".twnodes.com") && !url.includes("/naas/session/")) {
@@ -6659,11 +6761,11 @@ function patchNaasSession(sessionId) {
   };
 }
 function buildCoinTypeMap() {
-  const wc2 = getWalletCore();
+  const wc3 = getWalletCore();
   coinTypeByValue = /* @__PURE__ */ new Map();
-  for (const key of Object.keys(wc2.CoinType)) {
+  for (const key of Object.keys(wc3.CoinType)) {
     if (key === "values") continue;
-    const ct5 = wc2.CoinType[key];
+    const ct5 = wc3.CoinType[key];
     if (ct5 && typeof ct5 === "object" && typeof ct5.value === "number") {
       coinTypeByValue.set(ct5.value, ct5);
     }
@@ -6722,9 +6824,26 @@ function getWalletCore() {
 function isInitialized() {
   return initialized;
 }
-function _setWalletCore(wc2) {
-  walletCore = wc2;
-  initialized = wc2 !== null;
+function _setWalletCore(wc3) {
+  walletCore = wc3;
+  initialized = wc3 !== null;
+}
+function chainKeyToDefinedChain(chainKey) {
+  let coinId;
+  let canonicalKey;
+  try {
+    ({ coinId, chainKey: canonicalKey } = resolveAsset(chainKey));
+  } catch (err) {
+    if (err instanceof WalletError) {
+      throw new TwakValidationError(err.message, { chainKey });
+    }
+    throw err;
+  }
+  const ct5 = getCoinType(coinId);
+  if (!ct5) {
+    throw new TwakValidationError(`No CoinType mapping for coinId ${coinId}`, { chainKey, coinId });
+  }
+  return { chain: new import_trust_sdk3.DefinedChain(ct5), chainConfig: CHAINS[canonicalKey] };
 }
 function humanAmountToWei(amount, decimals = 18) {
   const parts = amount.split(".");
@@ -6733,6 +6852,13 @@ function humanAmountToWei(amount, decimals = 18) {
   const frac = parts[1].padEnd(decimals, "0").slice(0, decimals);
   return whole * 10n ** BigInt(decimals) + BigInt(frac);
 }
+function createPendingTransaction(client, chainKey, txHash) {
+  return {
+    txHash,
+    chainKey,
+    wait: (opts) => client.waitForReceipt(chainKey, txHash, opts)
+  };
+}
 function requireCoinType(coinId) {
   const ct5 = getCoinType(coinId);
   if (!ct5) {
@@ -6742,9 +6868,9 @@ function requireCoinType(coinId) {
 }
 function getCoinDecimals(coinId) {
   try {
-    const wc2 = getWalletCore();
+    const wc3 = getWalletCore();
     const ct5 = requireCoinType(coinId);
-    return wc2.CoinTypeConfiguration.getDecimals(ct5);
+    return wc3.CoinTypeConfiguration.getDecimals(ct5);
   } catch {
     const chain2 = getChainByCoinId(coinId);
     return chain2?.decimals ?? 18;
@@ -6787,10 +6913,39 @@ function tokenTypeForCoinId(coinId) {
       return import_trust_sdk2.TokenType.Erc20;
   }
 }
+async function signTransactionBytes(transaction, fee, nonce, hdWallet, ct5) {
+  try {
+    const signingResult = await import_trust_sdk2.BlockchainService.signWithHDWallet(
+      transaction,
+      fee,
+      nonce,
+      hdWallet
+    );
+    return signingResult.output[0];
+  } catch (err) {
+    if (!(err instanceof Error) || !err.message.includes("An operation is not implemented"))
+      throw err;
+    const privateKey = hdWallet.getKeyForCoin(ct5);
+    try {
+      const signingResult = await import_trust_sdk2.BlockchainService.signWithNonce(
+        transaction,
+        fee,
+        nonce,
+        privateKey
+      );
+      return signingResult.output[0];
+    } finally {
+      try {
+        privateKey.data().fill(0);
+      } catch {
+      }
+    }
+  }
+}
 async function getAmberDomainsByCoinId() {
   if (domainsByCoinId) return domainsByCoinId;
   try {
-    const domains = await import_trust_sdk4.AmberService.getDomains();
+    const domains = await import_trust_sdk5.AmberService.getDomains();
     domainsByCoinId = new Map(
       domains.map((d3) => [d3.coin.value, d3.id])
     );
@@ -6890,7 +7045,7 @@ function registerShutdownHandlers(providers, onBeforeExit) {
     process.removeListener("SIGTERM", handler);
   };
 }
-var fs2, path2, import_trust_sdk, import_trust_sdk2, import_trust_sdk3, import_trust_sdk4, import_crypto2, __require, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, SPONSORED_RPC, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, DEVICE_INFO_BODY, VerifyCredentialsError, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, WalletContext, SHUTDOWN_TIMEOUT_MS;
+var fs2, path2, import_trust_sdk, import_trust_sdk2, import_trust_sdk3, import_trust_sdk4, import_trust_sdk5, import_crypto2, __require, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, SPONSORED_RPC, RPC_TIMEOUT_MS, RECEIPT_POLL_INTERVAL_MS, RECEIPT_DEFAULT_TIMEOUT_MS, BlockchainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, DEVICE_INFO_BODY, VerifyCredentialsError, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, TeeWalletProvider, WalletContext, SHUTDOWN_TIMEOUT_MS;
 var init_dist3 = __esm({
   "../wallet-core/dist/index.mjs"() {
     "use strict";
@@ -6899,9 +7054,11 @@ var init_dist3 = __esm({
     import_trust_sdk = require("@trustwallet-trust-sdk/trust-sdk");
     import_trust_sdk2 = require("@trustwallet-trust-sdk/trust-sdk");
     init_dist();
-    init_dist();
     import_trust_sdk3 = require("@trustwallet-trust-sdk/trust-sdk");
+    init_dist();
+    init_dist();
     import_trust_sdk4 = require("@trustwallet-trust-sdk/trust-sdk");
+    import_trust_sdk5 = require("@trustwallet-trust-sdk/trust-sdk");
     init_dist();
     import_crypto2 = require("crypto");
     init_dist();
@@ -6918,6 +7075,7 @@ var init_dist3 = __esm({
     nodeStubsPatched = false;
     NAAS_SESSION_RE = /\/naas\/session\/[A-Za-z0-9+/_-]+=*\//;
     naasSessionPatched = false;
+    applyPolyfills();
     coinTypeByValue = null;
     walletCore = null;
     initialized = false;
@@ -6925,6 +7083,9 @@ var init_dist3 = __esm({
       20000714: "https://bsc-sponsored.twnodes.com",
       60: "https://ethereum-sponsored.twnodes.com"
     };
+    RPC_TIMEOUT_MS = 15e3;
+    RECEIPT_POLL_INTERVAL_MS = 1500;
+    RECEIPT_DEFAULT_TIMEOUT_MS = 6e4;
     BlockchainClient = class _BlockchainClient {
       signer;
       constructor(signer) {
@@ -7065,97 +7226,9 @@ var init_dist3 = __esm({
         );
         if (transaction7702) transaction = transaction7702;
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
-        let encodedTx;
-        try {
-          const signingResult = await import_trust_sdk2.BlockchainService.signWithHDWallet(
-            transaction,
-            fee,
-            nonce,
-            params.hdWallet
-          );
-          encodedTx = signingResult.output[0];
-        } catch (err) {
-          if (!(err instanceof Error) || !err.message.includes("An operation is not implemented"))
-            throw err;
-          const privateKey = params.hdWallet.getKeyForCoin(ct5);
-          try {
-            const signingResult = await import_trust_sdk2.BlockchainService.signWithNonce(
-              transaction,
-              fee,
-              nonce,
-              privateKey
-            );
-            encodedTx = signingResult.output[0];
-          } finally {
-            try {
-              privateKey.data().fill(0);
-            } catch {
-            }
-          }
-        }
-        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
-        return { hash, chainKey };
-      }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      async approve(params) {
-        const { coinId, contractAddress } = parseTokenId(params.assetId);
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) {
-          throw new Error(`Unsupported coin type: ${coinId}`);
-        }
-        if (!contractAddress) {
-          throw new Error("Cannot approve native token");
-        }
-        const ct5 = requireCoinType(coinId);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
-        const account = this.getAccountFromSigner(chainKey);
-        const asset = new import_trust_sdk2.Asset.Token(account, contractAddress, tokenTypeForCoinId(coinId));
-        const approveData = this.encodeApproveCalldata(params.spender, params.amount);
-        let transaction = new import_trust_sdk2.TransactionSmartContract(
-          asset,
-          contractAddress,
-          "0",
-          approveData
-        );
-        const { fee, transaction7702 } = await this.calculateFeeWithSponsorship(
-          transaction,
-          account,
-          coinId
-        );
-        if (transaction7702) transaction = transaction7702;
-        const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
-        let encodedTx;
-        try {
-          const signingResult = await import_trust_sdk2.BlockchainService.signWithHDWallet(
-            transaction,
-            fee,
-            nonce,
-            params.hdWallet
-          );
-          encodedTx = signingResult.output[0];
-        } catch (err) {
-          if (!(err instanceof Error) || !err.message.includes("An operation is not implemented"))
-            throw err;
-          const privateKey = params.hdWallet.getKeyForCoin(ct5);
-          try {
-            const signingResult = await import_trust_sdk2.BlockchainService.signWithNonce(
-              transaction,
-              fee,
-              nonce,
-              privateKey
-            );
-            encodedTx = signingResult.output[0];
-          } finally {
-            try {
-              privateKey.data().fill(0);
-            } catch {
-            }
-          }
-        }
-        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
-        return { hash, chainKey };
+        const encodedTx = await signTransactionBytes(transaction, fee, nonce, params.hdWallet, ct5);
+        return this.sendTransactionWithSponsorship(chain2, encodedTx, coinId, chainKey);
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async executeContract(params) {
         const { coinId } = parseTokenId(params.assetId);
         const chainKey = coinTypeToChainKey(coinId);
@@ -7180,74 +7253,67 @@ var init_dist3 = __esm({
         );
         if (transaction7702) transaction = transaction7702;
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
-        let encodedTx;
-        try {
-          const signingResult = await import_trust_sdk2.BlockchainService.signWithHDWallet(
-            transaction,
-            fee,
-            nonce,
-            params.hdWallet
+        const encodedTx = await signTransactionBytes(transaction, fee, nonce, params.hdWallet, ct5);
+        return this.sendTransactionWithSponsorship(chain2, encodedTx, coinId, chainKey);
+      }
+      /**
+       * Execute a read-only EVM `eth_call` against the chain's default RPC node.
+       * Returns the raw hex result string from the JSON-RPC envelope, or `'0x'`
+       * when the node omits a result. Errors surface as TwakNetworkError /
+       * TwakValidationError.
+       */
+      async ethCall(chainKey, to3, data) {
+        const rpcUrl = await this.resolveRpcUrl(chainKey);
+        const result = await this.postJsonRpc(rpcUrl, "eth_call", [{ to: to3, data }, "latest"]);
+        return result ?? "0x";
+      }
+      /**
+       * Poll `eth_getTransactionReceipt` until the transaction is mined or the
+       * timeout elapses. Defaults come from the chain's `receiptPollMs` /
+       * `receiptTimeoutMs` config when set, otherwise the global constants
+       * (1.5s poll, 60s timeout). Caller-supplied opts override both.
+       */
+      async waitForReceipt(chainKey, txHash, opts) {
+        const { chain: chain2, chainConfig } = chainKeyToDefinedChain(chainKey);
+        if (chainConfig?.namespace && chainConfig.namespace !== "eip155") {
+          throw new TwakValidationError(
+            `waitForReceipt is EVM-only; ${chainKey} is namespace ${chainConfig.namespace}`,
+            { chainKey, namespace: chainConfig.namespace }
           );
-          encodedTx = signingResult.output[0];
-        } catch (err) {
-          if (!(err instanceof Error) || !err.message.includes("An operation is not implemented"))
-            throw err;
-          const privateKey = params.hdWallet.getKeyForCoin(ct5);
-          try {
-            const signingResult = await import_trust_sdk2.BlockchainService.signWithNonce(
-              transaction,
-              fee,
-              nonce,
-              privateKey
-            );
-            encodedTx = signingResult.output[0];
-          } finally {
-            try {
-              privateKey.data().fill(0);
-            } catch {
-            }
-          }
         }
-        const hash = await this.sendTransactionWithSponsorship(chain2, encodedTx, coinId);
-        return { hash, chainKey };
-      }
-      async getAllowance(params) {
-        const { coinId, contractAddress } = parseTokenId(params.assetId);
-        if (!contractAddress) throw new Error("Allowance only applies to ERC-20 tokens");
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) throw new Error(`Unsupported coin type: ${coinId}`);
-        const chainDef = getChainByCoinId(coinId);
-        if (!chainDef?.isEVM) throw new Error(`Allowance is only supported on EVM chains`);
-        const ct5 = requireCoinType(coinId);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
-        const fnSelector = "dd62ed3e";
-        const paddedOwner = params.owner.replace("0x", "").padStart(64, "0");
-        const paddedSpender = params.spender.replace("0x", "").padStart(64, "0");
-        const calldata = "0x" + fnSelector + paddedOwner + paddedSpender;
-        const nodes = await import_trust_sdk2.BlockchainService.getNodes(chain2);
-        const rpcUrl = nodes[0]?.url;
-        if (!rpcUrl) throw new Error(`No RPC node available for ${chainKey}`);
-        const response = await fetch(rpcUrl, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            jsonrpc: "2.0",
-            id: 1,
-            method: "eth_call",
-            params: [{ to: contractAddress, data: calldata }, "latest"]
-          }),
-          signal: AbortSignal.timeout(15e3)
-        });
-        if (!response.ok) {
-          const body = await response.text().catch(() => "");
-          throw new Error(`RPC HTTP error ${response.status}: ${body.slice(0, 500)}`);
+        const timeoutMs = opts?.timeoutMs ?? chainConfig?.receiptTimeoutMs ?? RECEIPT_DEFAULT_TIMEOUT_MS;
+        const pollMs = opts?.pollMs ?? chainConfig?.receiptPollMs ?? RECEIPT_POLL_INTERVAL_MS;
+        if (timeoutMs <= 0) {
+          throw new TwakValidationError(`waitForReceipt: timeoutMs must be > 0 (got ${timeoutMs})`, {
+            chainKey,
+            timeoutMs
+          });
         }
-        const json = await response.json();
-        if (json.error) throw new Error(`RPC error: ${json.error.message}`);
-        if (!json.result || json.result === "0x") return 0n;
-        return BigInt(json.result);
+        if (pollMs <= 0) {
+          throw new TwakValidationError(`waitForReceipt: pollMs must be > 0 (got ${pollMs})`, {
+            chainKey,
+            pollMs
+          });
+        }
+        const rpcUrl = await this.rpcUrlForChain(chain2, chainKey);
+        const deadline = Date.now() + timeoutMs;
+        while (Date.now() < deadline) {
+          const remainingMs = Math.max(1, deadline - Date.now());
+          const result = await this.postJsonRpc(rpcUrl, "eth_getTransactionReceipt", [txHash], {
+            timeoutMs: Math.min(RPC_TIMEOUT_MS, remainingMs)
+          });
+          const receipt = result ?? null;
+          if (receipt) return receipt;
+          await new Promise((resolve2) => setTimeout(resolve2, pollMs));
+        }
+        throw new TwakNetworkError(`Timed out waiting for receipt ${txHash} on ${chainKey}`, {
+          txHash,
+          chainKey
+        });
+      }
+      contract(def) {
+        return def.using(this);
       }
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async transferRawSolana(params) {
         const ct5 = requireCoinType(501);
         const chain2 = new import_trust_sdk2.DefinedChain(ct5);
@@ -7268,31 +7334,9 @@ var init_dist3 = __esm({
         );
         const fee = await import_trust_sdk2.BlockchainService.calculateFee(trade);
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
-        let encodedTx;
-        try {
-          const signingResult = await import_trust_sdk2.BlockchainService.signWithHDWallet(
-            trade,
-            fee,
-            nonce,
-            params.hdWallet
-          );
-          encodedTx = signingResult.output[0];
-        } catch (err) {
-          if (!(err instanceof Error) || !err.message.includes("An operation is not implemented"))
-            throw err;
-          const privateKey = params.hdWallet.getKeyForCoin(ct5);
-          try {
-            const signingResult = await import_trust_sdk2.BlockchainService.signWithNonce(trade, fee, nonce, privateKey);
-            encodedTx = signingResult.output[0];
-          } finally {
-            try {
-              privateKey.data().fill(0);
-            } catch {
-            }
-          }
-        }
+        const encodedTx = await signTransactionBytes(trade, fee, nonce, params.hdWallet, ct5);
         const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
-        return { hash, chainKey: "solana" };
+        return createPendingTransaction(this, "solana", hash);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async signMessage(chainKey, message, privateKey) {
@@ -7410,7 +7454,7 @@ var init_dist3 = __esm({
        * Try sending via sponsored RPC first (checks pm_isSponsorable, then
        * eth_sendRawTransaction). Falls back to regular BlockchainService.
        */
-      async sendTransactionWithSponsorship(chain2, encodedTx, coinId) {
+      async sendTransactionWithSponsorship(chain2, encodedTx, coinId, chainKey) {
         const sponsoredUrl = this.getSponsoredRpcUrl(coinId);
         if (sponsoredUrl) {
           try {
@@ -7422,23 +7466,17 @@ var init_dist3 = __esm({
               rlpStart = offset;
             }
             const rawRlp = "0x" + Array.from(encodedTx.slice(rlpStart)).map((b3) => b3.toString(16).padStart(2, "0")).join("");
-            const resp = await fetch(sponsoredUrl, {
-              method: "POST",
-              headers: { "Content-Type": "application/json" },
-              body: JSON.stringify({
-                id: 0,
-                jsonrpc: "2.0",
-                method: "eth_sendRawTransaction",
-                params: [rawRlp]
-              }),
-              signal: AbortSignal.timeout(3e4)
+            const result = await this.postJsonRpc(sponsoredUrl, "eth_sendRawTransaction", [rawRlp], {
+              timeoutMs: 3e4
             });
-            const json = await resp.json();
-            if (json.result) return json.result;
+            if (typeof result === "string") {
+              return createPendingTransaction(this, chainKey, result);
+            }
           } catch {
           }
         }
-        return import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+        const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
+        return createPendingTransaction(this, chainKey, hash);
       }
       // Known stablecoins to try as gas payment tokens when getSupportedTokens returns empty
       static FALLBACK_GAS_TOKENS = {
@@ -7651,8 +7689,8 @@ var init_dist3 = __esm({
         }
         const ct5 = requireCoinType(coinId);
         const chain2 = new import_trust_sdk2.DefinedChain(ct5);
-        const wc2 = getWalletCore();
-        const derivation = coinId === 0 && address.startsWith("bc1p") ? wc2.Derivation.bitcoinTaproot : coinId === 0 && address.startsWith("bc1") ? wc2.Derivation.bitcoinSegwit : wc2.Derivation.default;
+        const wc3 = getWalletCore();
+        const derivation = coinId === 0 && address.startsWith("bc1p") ? wc3.Derivation.bitcoinTaproot : coinId === 0 && address.startsWith("bc1") ? wc3.Derivation.bitcoinSegwit : wc3.Derivation.default;
         return new import_trust_sdk2.Account(address, derivation, "", "", "", chain2);
       }
       async fetchBitcoinBalanceFromBlockbook(address) {
@@ -7666,11 +7704,61 @@ var init_dist3 = __esm({
         const total = BigInt(confirmed) + BigInt(unconfirmed);
         return { available: confirmed, total: total.toString() };
       }
-      encodeApproveCalldata(spender, amount) {
-        const fnSelector = "095ea7b3";
-        const paddedSpender = spender.replace("0x", "").padStart(64, "0");
-        const amountHex = BigInt(amount).toString(16).padStart(64, "0");
-        return "0x" + fnSelector + paddedSpender + amountHex;
+      async resolveRpcUrl(chainKey) {
+        const { chain: chain2 } = chainKeyToDefinedChain(chainKey);
+        return this.rpcUrlForChain(chain2, chainKey);
+      }
+      async rpcUrlForChain(chain2, chainKey) {
+        const nodes = await import_trust_sdk2.BlockchainService.getNodes(chain2);
+        const rpcUrl = nodes[0]?.url;
+        if (!rpcUrl) {
+          throw new TwakNetworkError(`No RPC node available for ${chainKey}`, { chainKey });
+        }
+        return rpcUrl;
+      }
+      async postJsonRpc(rpcUrl, method, params, opts) {
+        const timeoutMs = opts?.timeoutMs ?? RPC_TIMEOUT_MS;
+        let response;
+        try {
+          response = await fetch(rpcUrl, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
+            signal: AbortSignal.timeout(timeoutMs)
+          });
+        } catch (err) {
+          throw new TwakNetworkError(
+            `RPC fetch failed on ${method}: ${err instanceof Error ? err.message : String(err)}`,
+            { method, rpcUrl, timeoutMs }
+          );
+        }
+        if (!response.ok) {
+          const body = await response.text().catch(() => "");
+          const truncated = body.slice(0, 500);
+          throw new TwakNetworkError(`RPC HTTP error ${response.status} on ${method}: ${truncated}`, {
+            status: response.status,
+            method,
+            rpcUrl,
+            body: truncated
+          });
+        }
+        let json;
+        try {
+          json = await response.json();
+        } catch (err) {
+          throw new TwakNetworkError(
+            `RPC response JSON parse failed on ${method}: ${err instanceof Error ? err.message : String(err)}`,
+            { method, rpcUrl }
+          );
+        }
+        if (json.error) {
+          throw new TwakNetworkError(`RPC error on ${method}: ${json.error.message}`, {
+            method,
+            rpcUrl,
+            rpcError: json.error
+          });
+        }
+        return json.result;
       }
     };
     WalletCoreSigner = class _WalletCoreSigner {
@@ -7705,8 +7793,8 @@ var init_dist3 = __esm({
         if (!ct5) {
           throw new Error(`No CoinType mapping for chain: ${chainKey} (coinId: ${coinId})`);
         }
-        const chain2 = new import_trust_sdk3.DefinedChain(ct5);
-        const accounts = import_trust_sdk3.AccountManagementService.createDefaultAccountsHdWallet(chain2, this.hdWallet);
+        const chain2 = new import_trust_sdk4.DefinedChain(ct5);
+        const accounts = import_trust_sdk4.AccountManagementService.createDefaultAccountsHdWallet(chain2, this.hdWallet);
         if (accounts.length === 0) {
           throw new Error(`No accounts for chain: ${chainKey}`);
         }
@@ -7725,8 +7813,8 @@ var init_dist3 = __esm({
         if (!ct5) {
           throw new Error(`No CoinType mapping for chain: ${chainKey} (coinId: ${coinId})`);
         }
-        const chain2 = new import_trust_sdk3.DefinedChain(ct5);
-        const accounts = import_trust_sdk3.AccountManagementService.createDefaultAccountsHdWallet(chain2, this.hdWallet);
+        const chain2 = new import_trust_sdk4.DefinedChain(ct5);
+        const accounts = import_trust_sdk4.AccountManagementService.createDefaultAccountsHdWallet(chain2, this.hdWallet);
         if (accounts.length === 0) {
           throw new Error(`No accounts for chain: ${chainKey}`);
         }
@@ -7937,23 +8025,10 @@ var init_dist3 = __esm({
           hdWallet: this.signer.getHDWallet()
         });
       }
-      async approveErc20(chainKey, token, spender, amount) {
-        await this.ensureConnected();
-        this.resetAutoLockTimer();
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) throw new Error(`Unsupported chain: ${chainKey}`);
-        const result = await this.blockchainClient.approve({
-          assetId: `c${coinId}_t${token}`,
-          spender,
-          amount,
-          hdWallet: this.signer.getHDWallet()
-        });
-        return { txHash: result.hash };
-      }
       async sendTransaction(params) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
-        const { getChainByEvmId: getChainByEvmId2, chainKeyToCoinType: chainKeyToCoinType4 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
+        const { getChainByEvmId: getChainByEvmId2, chainKeyToCoinType: chainKeyToCoinType3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
         let assetId;
         if (params.chainId.startsWith("eip155:")) {
           const chain2 = getChainByEvmId2(params.chainId.replace("eip155:", ""));
@@ -7962,7 +8037,7 @@ var init_dist3 = __esm({
         } else if (params.chainId.startsWith("solana:")) {
           assetId = "c501";
         } else {
-          const coinId = chainKeyToCoinType4(params.chainId);
+          const coinId = chainKeyToCoinType3(params.chainId);
           if (coinId === void 0) throw new Error(`Unsupported chain: ${params.chainId}`);
           assetId = `c${coinId}`;
         }
@@ -7974,7 +8049,7 @@ var init_dist3 = __esm({
             serializedMessage: params.data,
             hdWallet
           });
-          return result2.hash;
+          return result2.txHash;
         }
         if (hasCalldata || hasValue) {
           const result2 = await this.blockchainClient.executeContract({
@@ -7984,7 +8059,7 @@ var init_dist3 = __esm({
             data: params.data || "0x",
             hdWallet
           });
-          return result2.hash;
+          return result2.txHash;
         }
         const result = await this.blockchainClient.transfer({
           assetId,
@@ -7992,7 +8067,7 @@ var init_dist3 = __esm({
           amount: params.value || "0",
           hdWallet
         });
-        return result.hash;
+        return result.txHash;
       }
       supportsChain(chainId) {
         return isChainSupported(chainId);
@@ -8032,6 +8107,39 @@ var init_dist3 = __esm({
         return this.signer;
       }
     };
+    TeeWalletProvider = class extends WalletProvider {
+      name = "tee";
+      address = null;
+      async getAddress(_chainId) {
+        if (!this.address) throw new Error("TEE wallet not initialized");
+        return this.address;
+      }
+      async getAddresses() {
+        if (!this.address) return [];
+        return [{ address: this.address, chainId: "eip155:1" }];
+      }
+      async signMessage(_chainId, _message) {
+        throw new Error("TEE signing not yet implemented");
+      }
+      async signTypedData(_chainKey, _chainId, _typedDataJson) {
+        throw new Error("TEE signing not yet implemented");
+      }
+      async sendTransaction(_params) {
+        throw new Error("TEE transaction sending not yet implemented");
+      }
+      supportsChain(_chainId) {
+        return false;
+      }
+      async connect(_chains) {
+        throw new Error("TEE wallet connect not yet implemented");
+      }
+      async disconnect() {
+        this.address = null;
+      }
+      isConnected() {
+        return this.address !== null;
+      }
+    };
     WalletContext = class {
       _state = "unbound";
       _wallet;
@@ -8163,13 +8271,13 @@ var init_dist3 = __esm({
        * to avoid forcing wallet-core to depend on it. The caller (typically the
        * MCP action provider) constructs the WC provider and passes it in.
        */
-      async beginWalletConnect(wc2, chains) {
-        return this.enqueue(() => this.beginWalletConnectImpl(wc2, chains));
+      async beginWalletConnect(wc3, chains) {
+        return this.enqueue(() => this.beginWalletConnectImpl(wc3, chains));
       }
-      async beginWalletConnectImpl(wc2, chains) {
+      async beginWalletConnectImpl(wc3, chains) {
         await this.disconnectWcIfAny();
         try {
-          this._pairing = await wc2.connect(chains);
+          this._pairing = await wc3.connect(chains);
         } catch (err) {
           this._wallet = void 0;
           this._pendingWc = void 0;
@@ -8183,20 +8291,20 @@ var init_dist3 = __esm({
           throw err;
         }
         this._wallet = void 0;
-        this._pendingWc = wc2;
+        this._pendingWc = wc3;
         this._state = "wc-pairing";
         this._lastError = void 0;
         this._peerName = void 0;
-        wc2.onSessionEstablished((session) => {
-          if (this._pendingWc !== wc2) return;
-          this._wallet = wc2;
+        wc3.onSessionEstablished((session) => {
+          if (this._pendingWc !== wc3) return;
+          this._wallet = wc3;
           this._peerName = session.peerName;
           this._state = "wc-connected";
           this._pendingWc = void 0;
           this._pairing = void 0;
         });
-        wc2.onSessionEnded((reason) => {
-          if (this._wallet !== wc2) return;
+        wc3.onSessionEnded((reason) => {
+          if (this._wallet !== wc3) return;
           this._wallet = void 0;
           this._pairing = void 0;
           this._peerName = void 0;
@@ -8226,35 +8334,6 @@ var init_dist3 = __esm({
   }
 });
 
-// ../blockchain/dist/index.mjs
-var dist_exports2 = {};
-__export(dist_exports2, {
-  BlockchainClient: () => BlockchainClient,
-  VerifyCredentialsError: () => VerifyCredentialsError,
-  WalletCoreSigner: () => WalletCoreSigner,
-  _setWalletCore: () => _setWalletCore,
-  applyPolyfills: () => applyPolyfills,
-  buildCoinTypeMap: () => buildCoinTypeMap,
-  getAmberDomainsByCoinId: () => getAmberDomainsByCoinId,
-  getCoinType: () => getCoinType,
-  getWalletCore: () => getWalletCore,
-  humanAmountToWei: () => humanAmountToWei,
-  initTrustSDK: () => initTrustSDK,
-  isInitialized: () => isInitialized,
-  patchNaasSession: () => patchNaasSession,
-  patchNodeStubs: () => patchNodeStubs,
-  registerDeviceAndWallet: () => registerDeviceAndWallet,
-  setPolyfillCredentials: () => setPolyfillCredentials,
-  setPolyfillNaasSessionId: () => setPolyfillNaasSessionId,
-  verifyCredentials: () => verifyCredentials
-});
-var init_dist4 = __esm({
-  "../blockchain/dist/index.mjs"() {
-    "use strict";
-    init_dist3();
-  }
-});
-
 // ../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js
 var tslib_es6_exports = {};
 __export(tslib_es6_exports, {
@@ -13555,10 +13634,10 @@ var require_boxen = __commonJS({
       }
       return lines.join(NL);
     };
-    var isHex = (color) => color.match(/^#(?:[0-f]{3}){1,2}$/i);
-    var isColorValid = (color) => typeof color === "string" && (chalk9[color] || isHex(color));
-    var getColorFn = (color) => isHex(color) ? chalk9.hex(color) : chalk9[color];
-    var getBGColorFn = (color) => isHex(color) ? chalk9.bgHex(color) : chalk9[camelCase(["bg", color])];
+    var isHex2 = (color) => color.match(/^#(?:[0-f]{3}){1,2}$/i);
+    var isColorValid = (color) => typeof color === "string" && (chalk9[color] || isHex2(color));
+    var getColorFn = (color) => isHex2(color) ? chalk9.hex(color) : chalk9[color];
+    var getBGColorFn = (color) => isHex2(color) ? chalk9.bgHex(color) : chalk9[camelCase(["bg", color])];
     module2.exports = (text, options) => {
       options = {
         padding: 0,
@@ -23039,7 +23118,7 @@ function safeExit() {
 // src/config-loader.ts
 var import_chalk2 = __toESM(require_source());
 init_dist();
-init_dist4();
+init_dist3();
 init_dist2();
 var EMBEDDED_NAAS_SESSION_ID = "Nr8eogRKLULRxGpVkeMqQBoDpGnZxgYjKK7tu6bKxqUn6eZU";
 function resolveNaasSessionId() {
@@ -28267,7 +28346,7 @@ function weierstrassPoints(opts) {
   const CURVE = validatePointOpts(opts);
   const { Fp } = CURVE;
   const Fn3 = Field(CURVE.n, CURVE.nBitLength);
-  const toBytes4 = CURVE.toBytes || ((_c2, point, _isCompressed) => {
+  const toBytes5 = CURVE.toBytes || ((_c2, point, _isCompressed) => {
     const a3 = point.toAffine();
     return concatBytes2(Uint8Array.from([4]), Fp.toBytes(a3.x), Fp.toBytes(a3.y));
   });
@@ -28647,7 +28726,7 @@ function weierstrassPoints(opts) {
     toRawBytes(isCompressed = true) {
       abool("isCompressed", isCompressed);
       this.assertValidity();
-      return toBytes4(Point, this, isCompressed);
+      return toBytes5(Point, this, isCompressed);
     }
     toHex(isCompressed = true) {
       abool("isCompressed", isCompressed);
@@ -28951,16 +29030,16 @@ function weierstrass(curveDef) {
       throw new Error("options.strict was renamed to lowS");
     if (format !== void 0 && format !== "compact" && format !== "der")
       throw new Error("format must be compact or der");
-    const isHex = typeof sg === "string" || isBytes2(sg);
-    const isObj = !isHex && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
-    if (!isHex && !isObj)
+    const isHex2 = typeof sg === "string" || isBytes2(sg);
+    const isObj = !isHex2 && !format && typeof sg === "object" && sg !== null && typeof sg.r === "bigint" && typeof sg.s === "bigint";
+    if (!isHex2 && !isObj)
       throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
     let _sig = void 0;
     let P5;
     try {
       if (isObj)
         _sig = new Signature(sg.r, sg.s);
-      if (isHex) {
+      if (isHex2) {
         try {
           if (format !== "compact")
             _sig = Signature.fromDER(sg);
@@ -39097,22 +39176,6 @@ var WalletConnectProvider = class extends WalletProvider {
       }
     });
   }
-  async approveErc20(chainKey, token, spender, amount) {
-    const chain2 = getChainById(chainKey);
-    if (!chain2) throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported chain: ${chainKey}`);
-    const caipChainId = `${chain2.namespace}:${chain2.chainId}`;
-    const selector = "0x095ea7b3";
-    const paddedSpender = spender.replace(/^0x/, "").toLowerCase().padStart(64, "0");
-    const paddedAmount = BigInt(amount).toString(16).padStart(64, "0");
-    const data = selector + paddedSpender + paddedAmount;
-    const txHash = await this.sendTransaction({
-      chainId: caipChainId,
-      to: token,
-      data,
-      value: "0x0"
-    });
-    return { txHash };
-  }
   async sendTransaction(params) {
     const session = this.getActiveSession();
     if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
@@ -39643,11 +39706,19 @@ var import_prompts = require("@inquirer/prompts");
 init_dist2();
 init_dist();
 var PORTAL_URL = "https://portal.trustwallet.com/dashboard/apps";
+var WC_DASHBOARD_URL = "https://dashboard.walletconnect.com/";
 var defaultPrompter = {
   promptAccessId: () => (0, import_prompts.input)({
     message: "Access ID:",
     validate: (s2) => s2.trim().length > 0 ? true : "Access ID is required"
   }),
+  promptWalletConnectProjectId: async () => {
+    const wc3 = await (0, import_prompts.input)({
+      message: "WalletConnect Project ID (optional):",
+      required: false
+    });
+    return wc3.trim() || void 0;
+  },
   promptHmacSecret: () => (0, import_prompts.password)({
     message: "HMAC secret:",
     mask: "\u25CF",
@@ -39668,19 +39739,13 @@ async function runCredentialsPhase(opts, deps = makeDefaultDeps()) {
     success(`Credentials already configured (access ID ${existing.accessId.slice(0, 8)})`);
     return;
   }
-  const isRotation = existing !== null;
   if (opts.nonInteractive) {
     await runNonInteractive(deps);
   } else {
-    info(`Get your API Credentials at: ${PORTAL_URL}
+    info(`Get your Trust Wallet API credentials at: ${PORTAL_URL}
 `);
     await runInteractive(deps);
   }
-  if (isRotation) {
-    warn(
-      "Heads up: if you previously hand-pasted `env: { TWAK_HMAC_SECRET: '\u2026' }` into a harness's MCP config, that value is now stale. The canonical twak entry pulls credentials from ~/.twak/credentials.json \u2014 drop any explicit env blocks so the new secret is used."
-    );
-  }
 }
 async function runNonInteractive(deps) {
   const accessId = deps.env.TWAK_ACCESS_ID?.trim();
@@ -39691,13 +39756,21 @@ async function runNonInteractive(deps) {
       "Non-interactive setup requires TWAK_ACCESS_ID and TWAK_HMAC_SECRET in the environment."
     );
   }
-  const result = await deps.credManager.save({ accessId, hmacSecret });
+  const walletConnectProjectId = deps.env.WALLETCONNECT_PROJECT_ID?.trim() || void 0;
+  const result = await deps.credManager.save({ accessId, hmacSecret, walletConnectProjectId });
   success(`Saved access ID ${accessId.slice(0, 8)} to ${storageLocation(result.keychain)}`);
 }
 async function runInteractive(deps) {
   const accessId = (await deps.prompter.promptAccessId()).trim();
   const hmacSecret = (await deps.prompter.promptHmacSecret()).trim();
-  const result = await deps.credManager.save({ accessId, hmacSecret });
+  info(
+    `
+WalletConnect Project ID is only used when signing via WalletConnect in MCP mode.
+Skip if you only plan to use the local agent wallet. Get one at: ${WC_DASHBOARD_URL}
+`
+  );
+  const walletConnectProjectId = (await deps.prompter.promptWalletConnectProjectId())?.trim() || void 0;
+  const result = await deps.credManager.save({ accessId, hmacSecret, walletConnectProjectId });
   success(`Saved access ID ${accessId.slice(0, 8)} to ${storageLocation(result.keychain)}`);
 }
 function storageLocation(keychain) {
@@ -40184,6 +40257,16 @@ function isNonInteractive() {
 function printSetupBanner() {
   process.stderr.write("\n" + import_chalk3.default.bold("\u26D3  Trust Wallet Agent Kit \u2014 Setup") + "\n\n");
 }
+function printNextSteps() {
+  const harnessNames = ALL_HARNESSES.slice(0, 3).map((h4) => h4.displayName).join(", ");
+  info(
+    `
+Next steps:
+  1. Restart your harness (${harnessNames}, etc.) so it picks up twak.
+  2. Try a sample query, e.g. "What is my wallet address on Ethereum?"
+`
+  );
+}
 async function runSetup(opts, phases = defaultPhases) {
   const noFlags = !opts.reconfigureCreds && !opts.harness && !opts.wallet;
   if (noFlags || opts.reconfigureCreds) await phases.credentials(opts);
@@ -40206,6 +40289,7 @@ function registerSetupCommand(program3) {
       printSetupBanner();
       await runSetup(opts);
       success("Setup complete.");
+      printNextSteps();
     } catch (err) {
       handleCommandError(err, false, "Setup failed");
     }
@@ -41539,11 +41623,11 @@ function registerTransferCommand(program3) {
       } catch (err) {
         mapBroadcastError(err);
       }
-      const explorerUrl = getExplorerTxUrl(result.chainKey, result.hash);
+      const explorerUrl = getExplorerTxUrl(result.chainKey, result.txHash);
       success("Transfer sent!");
       output(
         {
-          hash: result.hash,
+          hash: result.txHash,
           chain: result.chainKey,
           from: address,
           to: resolvedTo,
@@ -41562,7 +41646,681 @@ function registerTransferCommand(program3) {
 
 // src/commands/swap.ts
 init_dist();
-init_dist4();
+init_dist3();
+
+// ../contracts/dist/index.mjs
+init_dist();
+init_dist();
+init_dist();
+init_dist();
+init_dist3();
+init_dist();
+var HEX_PATTERN = /^0x[0-9a-fA-F]*$/;
+function isHex(value) {
+  return HEX_PATTERN.test(value);
+}
+function hexToBytes2(hex2) {
+  if (!isHex(hex2)) {
+    throw new TwakValidationError(`Invalid hex string: ${hex2}`, { kind: "invalidHex" });
+  }
+  const clean2 = hex2.slice(2);
+  if (clean2.length % 2 !== 0) {
+    throw new TwakValidationError(`Hex string has odd length: ${hex2}`, { kind: "invalidHex" });
+  }
+  const out = new Uint8Array(clean2.length / 2);
+  for (let i2 = 0; i2 < out.length; i2++) {
+    out[i2] = parseInt(clean2.slice(i2 * 2, i2 * 2 + 2), 16);
+  }
+  return out;
+}
+function bytesToHex2(bytes) {
+  let out = "0x";
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    out += bytes[i2].toString(16).padStart(2, "0");
+  }
+  return out;
+}
+function wc2() {
+  return getWalletCore();
+}
+var BRIDGE = {
+  createAbiFunction(name2) {
+    const ctor = wc2().EthereumAbiFunction;
+    if (typeof ctor?.createWithString === "function") {
+      return ctor.createWithString(name2);
+    }
+    return new ctor(name2);
+  },
+  encode(fn2) {
+    return wc2().EthereumAbi.encode(fn2);
+  },
+  decodeOutput(fn2, data) {
+    return wc2().EthereumAbi.decodeOutput(fn2, data);
+  },
+  keccak256(data) {
+    return wc2().Hash.keccak256(data);
+  }
+};
+function getAbiBridge() {
+  return BRIDGE;
+}
+function findAbiFunction(abi, methodName) {
+  const entry = abi.find(
+    (e2) => e2.type === "function" && e2.name === methodName
+  );
+  if (!entry) {
+    throw new TwakValidationError(`Unknown ABI method: ${methodName}`, {
+      kind: "unknownMethod",
+      methodName
+    });
+  }
+  return entry;
+}
+function encodeFunctionCall(abi, methodName, args) {
+  const fnDef = findAbiFunction(abi, methodName);
+  if (args.length !== fnDef.inputs.length) {
+    throw new TwakValidationError(
+      `Wrong arg count for ${methodName}: expected ${fnDef.inputs.length}, got ${args.length}`,
+      {
+        kind: "wrongArgCount",
+        methodName,
+        expected: fnDef.inputs.length,
+        actual: args.length
+      }
+    );
+  }
+  const bridge = getAbiBridge();
+  const fn2 = bridge.createAbiFunction(methodName);
+  fnDef.inputs.forEach((param, i2) => {
+    pushParam(fn2, param, args[i2], methodName);
+  });
+  return bytesToHex2(bridge.encode(fn2));
+}
+function pushParam(fn2, param, value, methodName) {
+  const type = param.type;
+  const isOutput = false;
+  if (type === "address") {
+    fn2.addParamAddress(toAddressBytes(value, param, methodName), isOutput);
+    return;
+  }
+  if (type === "bool") {
+    if (typeof value !== "boolean") {
+      throw argTypeMismatch(methodName, param, value, "boolean");
+    }
+    fn2.addParamBool(value, isOutput);
+    return;
+  }
+  if (type === "string") {
+    if (typeof value !== "string") {
+      throw argTypeMismatch(methodName, param, value, "string");
+    }
+    fn2.addParamString(value, isOutput);
+    return;
+  }
+  if (type === "bytes") {
+    fn2.addParamBytes(toBytes4(value, param, methodName), isOutput);
+    return;
+  }
+  const bytesNMatch = /^bytes(\d+)$/.exec(type);
+  if (bytesNMatch) {
+    const size3 = Number(bytesNMatch[1]);
+    fn2.addParamBytesFix(toBytesFix(value, size3, param, methodName), size3, isOutput);
+    return;
+  }
+  const intMatch = /^(u?)int(\d*)$/.exec(type);
+  if (intMatch) {
+    const isUnsigned = intMatch[1] === "u";
+    const bits = intMatch[2] ? Number(intMatch[2]) : 256;
+    if (bits < 8 || bits > 256 || bits % 8 !== 0) {
+      throw new TwakValidationError(
+        `Unsupported integer width ${type} for ${methodName}.${param.name} (expected 8..256, multiple of 8)`,
+        { kind: "argTypeMismatch", methodName, paramName: param.name, type }
+      );
+    }
+    const bigValue = toBigInt2(value, param, methodName);
+    if (isUnsigned) {
+      if (bigValue < 0n || bigValue >= 1n << BigInt(bits)) {
+        throw argTypeMismatch(methodName, param, value, `uint${bits} (0 <= x < 2^${bits})`);
+      }
+    } else {
+      const limit = 1n << BigInt(bits - 1);
+      if (bigValue < -limit || bigValue >= limit) {
+        throw argTypeMismatch(
+          methodName,
+          param,
+          value,
+          `int${bits} (-2^${bits - 1} <= x < 2^${bits - 1})`
+        );
+      }
+    }
+    const bytes = bigIntToBytes32(bigValue, isUnsigned);
+    if (isUnsigned) {
+      fn2.addParamUInt256(bytes, isOutput);
+    } else {
+      fn2.addParamInt256(bytes, isOutput);
+    }
+    return;
+  }
+  throw new TwakValidationError(
+    `Unsupported ABI param type "${type}" for ${methodName}.${param.name}`,
+    {
+      kind: "argTypeMismatch",
+      methodName,
+      paramName: param.name,
+      type
+    }
+  );
+}
+function toAddressBytes(value, param, methodName) {
+  if (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)) {
+    throw argTypeMismatch(methodName, param, value, "address (0x + 40 hex)");
+  }
+  return hexToBytes2(value);
+}
+function bigIntToBytes32(value, isUnsigned) {
+  let v5 = value;
+  if (!isUnsigned && v5 < 0n) {
+    v5 = (1n << 256n) + v5;
+  }
+  const out = new Uint8Array(32);
+  for (let i2 = 31; i2 >= 0; i2--) {
+    out[i2] = Number(v5 & 0xffn);
+    v5 >>= 8n;
+  }
+  return out;
+}
+function toBigInt2(value, param, methodName) {
+  if (typeof value === "bigint") return value;
+  if (typeof value === "number") {
+    if (!Number.isSafeInteger(value)) {
+      throw argTypeMismatch(
+        methodName,
+        param,
+        value,
+        "safe integer (use bigint or string for values >2^53)"
+      );
+    }
+    return BigInt(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) return BigInt(value);
+  if (typeof value === "string" && /^0x[0-9a-fA-F]+$/.test(value)) return BigInt(value);
+  throw argTypeMismatch(methodName, param, value, "integer (bigint | number | numeric string)");
+}
+function toBytes4(value, param, methodName) {
+  if (value instanceof Uint8Array) return value;
+  if (typeof value === "string" && /^0x[0-9a-fA-F]*$/.test(value)) {
+    return hexToBytes2(value);
+  }
+  throw argTypeMismatch(methodName, param, value, "bytes (Uint8Array | 0x-prefixed hex)");
+}
+function toBytesFix(value, size3, param, methodName) {
+  const bytes = toBytes4(value, param, methodName);
+  if (bytes.length !== size3) {
+    throw new TwakValidationError(
+      `Wrong byte length for ${methodName}.${param.name}: expected ${size3}, got ${bytes.length}`,
+      {
+        kind: "argTypeMismatch",
+        methodName,
+        paramName: param.name,
+        expected: size3,
+        actual: bytes.length
+      }
+    );
+  }
+  return bytes;
+}
+function argTypeMismatch(methodName, param, value, expected) {
+  return new TwakValidationError(
+    `Arg type mismatch for ${methodName}.${param.name}: expected ${expected}, got ${typeof value}`,
+    {
+      kind: "argTypeMismatch",
+      methodName,
+      paramName: param.name,
+      expected,
+      actual: typeof value
+    }
+  );
+}
+function decodeFunctionResult(abi, methodName, returnHex) {
+  const fnDef = findAbiFunction(abi, methodName);
+  if (fnDef.outputs.length === 0) return void 0;
+  const data = hexToBytes2(returnHex);
+  if (data.length === 0) {
+    throw new TwakValidationError(
+      `Empty return data for ${methodName} \u2014 call likely reverted or contract has no code at address`,
+      { kind: "decodeFailed", methodName }
+    );
+  }
+  const bridge = getAbiBridge();
+  const fn2 = bridge.createAbiFunction(methodName);
+  fnDef.outputs.forEach((param) => addOutputParam(fn2, param, methodName));
+  const ok = bridge.decodeOutput(fn2, data);
+  if (!ok) {
+    throw new TwakValidationError(`decodeOutput failed for ${methodName}`, {
+      kind: "decodeFailed",
+      methodName
+    });
+  }
+  if (fnDef.outputs.length === 1) {
+    return readOutputParam(fn2, fnDef.outputs[0], 0, methodName);
+  }
+  const unnamed = fnDef.outputs.find((p3) => p3.name === "");
+  if (unnamed) {
+    throw new TwakValidationError(
+      `Cannot decode multi-output function ${methodName}: every output must be named in the ABI (found unnamed output of type "${unnamed.type}")`,
+      { kind: "decodeFailed", methodName }
+    );
+  }
+  const result = /* @__PURE__ */ Object.create(null);
+  fnDef.outputs.forEach((param, i2) => {
+    result[param.name] = readOutputParam(fn2, param, i2, methodName);
+  });
+  return result;
+}
+function decodeLog(abi, log) {
+  const events = abi.filter((e2) => e2.type === "event");
+  for (const event of events) {
+    if (event.anonymous) {
+      throw new TwakValidationError(
+        `Decoding anonymous events is not supported (${event.name}): they emit no signature topic to match against`,
+        { kind: "unsupportedType", methodName: event.name }
+      );
+    }
+    const topic0 = bytesToHex2(keccak256Utf8(canonicalEventSignature(event)));
+    if (topic0.toLowerCase() !== (log.topics[0] ?? "").toLowerCase()) continue;
+    const indexed = event.inputs.filter((p3) => p3.indexed);
+    const unindexed = event.inputs.filter((p3) => !p3.indexed);
+    const args = {};
+    indexed.forEach((param, i2) => {
+      const topic = log.topics[i2 + 1];
+      if (!topic) {
+        throw new TwakValidationError(`Missing indexed topic for ${event.name}.${param.name}`, {
+          kind: "decodeFailed",
+          methodName: event.name,
+          paramName: param.name
+        });
+      }
+      args[param.name] = decodeIndexedTopic(param, topic);
+    });
+    if (unindexed.length > 0) {
+      const bridge = getAbiBridge();
+      const fn2 = bridge.createAbiFunction(event.name);
+      unindexed.forEach((param) => addOutputParam(fn2, param, event.name));
+      const dataBytes = hexToBytes2(log.data);
+      const ok = bridge.decodeOutput(fn2, dataBytes);
+      if (!ok) {
+        throw new TwakValidationError(`decodeOutput failed for event ${event.name}`, {
+          kind: "decodeFailed",
+          methodName: event.name
+        });
+      }
+      unindexed.forEach((param, i2) => {
+        args[param.name] = readOutputParam(fn2, param, i2, event.name);
+      });
+    }
+    return { eventName: event.name, args };
+  }
+  return null;
+}
+function addOutputParam(fn2, param, methodName) {
+  const type = param.type;
+  if (type === "address") {
+    fn2.addParamAddress(new Uint8Array(20), true);
+    return;
+  }
+  if (type === "bool") {
+    fn2.addParamBool(false, true);
+    return;
+  }
+  if (type === "string") {
+    fn2.addParamString("", true);
+    return;
+  }
+  if (/^int\d*$/.test(type)) {
+    throw new TwakValidationError(
+      `Decoding signed integer outputs (${type}) is not supported in v1 \u2014 wallet-core lacks getParamInt*. See contract-abstraction sc-138140 follow-up.`,
+      { kind: "unsupportedType", methodName, paramName: param.name, type }
+    );
+  }
+  if (/^uint\d*$/.test(type)) {
+    fn2.addParamUInt256(new Uint8Array(32), true);
+    return;
+  }
+  throw new TwakValidationError(
+    `Unsupported output type "${type}" for ${methodName}.${param.name}`,
+    { kind: "decodeFailed", methodName, paramName: param.name }
+  );
+}
+function readOutputParam(fn2, param, idx, methodName) {
+  const type = param.type;
+  if (type === "address") {
+    const raw = fn2.getParamAddress(idx, true);
+    return normalizeAddress(raw);
+  }
+  if (type === "bool") {
+    return Boolean(fn2.getParamBool(idx, true));
+  }
+  if (type === "string") {
+    return String(fn2.getParamString(idx, true));
+  }
+  if (/^uint\d*$/.test(type)) {
+    const raw = fn2.getParamUInt256(idx, true);
+    return bytesToBigInt(raw);
+  }
+  throw new TwakValidationError(
+    `Unsupported output type "${type}" for ${methodName}.${param.name}`,
+    { kind: "decodeFailed", methodName, paramName: param.name }
+  );
+}
+function decodeIndexedTopic(param, topicHex) {
+  const bytes = hexToBytes2(topicHex);
+  if (bytes.length !== 32) {
+    throw new TwakValidationError(
+      `Indexed topic for ${param.name} is not 32 bytes (got ${bytes.length})`,
+      { kind: "decodeFailed", paramName: param.name }
+    );
+  }
+  const type = param.type;
+  if (type === "address") {
+    return normalizeAddress(bytes.slice(12));
+  }
+  if (type === "bool") {
+    return bytes[31] !== 0;
+  }
+  if (/^int\d*$/.test(type)) {
+    throw new TwakValidationError(
+      `Decoding signed integer topics (${type}) is not supported in v1`,
+      { kind: "unsupportedType", paramName: param.name, type }
+    );
+  }
+  if (/^uint\d*$/.test(type)) {
+    return bytesToBigInt(bytes);
+  }
+  if (/^bytes32$/.test(type)) {
+    return bytesToHex2(bytes);
+  }
+  return bytesToHex2(bytes);
+}
+function canonicalEventSignature(event) {
+  return `${event.name}(${event.inputs.map((i2) => i2.type).join(",")})`;
+}
+function keccak256Utf8(s2) {
+  return getAbiBridge().keccak256(new TextEncoder().encode(s2));
+}
+function bytesToBigInt(bytes) {
+  let v5 = 0n;
+  for (let i2 = 0; i2 < bytes.length; i2++) {
+    v5 = v5 << 8n | BigInt(bytes[i2]);
+  }
+  return v5;
+}
+function normalizeAddress(raw) {
+  if (typeof raw === "string") {
+    return raw.startsWith("0x") ? raw.toLowerCase() : "0x" + raw.toLowerCase();
+  }
+  if (raw && typeof raw === "object" && "length" in raw) {
+    return bytesToHex2(raw);
+  }
+  throw new TwakValidationError(`Unexpected address shape from wallet-core: ${typeof raw}`, {
+    kind: "decodeFailed"
+  });
+}
+function createContractInstance(opts) {
+  const { abi, address, chainKey, client } = opts;
+  if (!EVM_ADDRESS_RE.test(address)) {
+    throw new TwakValidationError(`Invalid EVM contract address: ${address}`, {
+      kind: "invalidAddress",
+      address
+    });
+  }
+  const chainDef = requireChain(chainKey);
+  if (chainDef.namespace !== "eip155") {
+    throw new TwakValidationError(
+      `Contract calls are EVM-only; ${chainKey} is namespace ${chainDef.namespace}`,
+      { chainKey, namespace: chainDef.namespace }
+    );
+  }
+  return {
+    address,
+    chainKey,
+    abi,
+    read: buildReadProxy(abi, address, chainKey, client),
+    write: buildWriteProxy(abi, address, chainKey, client)
+  };
+}
+function indexAbiFunctions(abi) {
+  const names = /* @__PURE__ */ new Set();
+  for (const entry of abi) {
+    if (entry.type === "function") {
+      const name2 = entry.name;
+      if (typeof name2 === "string") names.add(name2);
+    }
+  }
+  return names;
+}
+function buildReadProxy(abi, address, chainKey, client) {
+  const fnNames = indexAbiFunctions(abi);
+  return new Proxy({}, {
+    get(_2, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (isJsInternal(prop)) return void 0;
+      if (!fnNames.has(prop)) findAbiFunction(abi, prop);
+      return async (args = []) => {
+        const data = encodeFunctionCall(abi, prop, args);
+        const returnHex = await client.ethCall(chainKey, address, data);
+        return decodeFunctionResult(abi, prop, returnHex);
+      };
+    }
+  });
+}
+function buildWriteProxy(abi, address, chainKey, client) {
+  const fnNames = indexAbiFunctions(abi);
+  return new Proxy({}, {
+    get(_2, prop) {
+      if (typeof prop !== "string") return void 0;
+      if (isJsInternal(prop)) return void 0;
+      if (!fnNames.has(prop)) findAbiFunction(abi, prop);
+      return async (args = [], signer) => {
+        if (!signer) {
+          throw new TwakValidationError(`Missing signer for write call to ${prop}`, {
+            kind: "missingSigner",
+            methodName: prop
+          });
+        }
+        const data = encodeFunctionCall(abi, prop, args);
+        const txHash = await signer.sendTransaction({
+          chainId: chainKeyToCaip2(chainKey),
+          to: address,
+          data,
+          value: "0x0"
+        });
+        return makeContractPendingTransaction({
+          txHash,
+          abi,
+          address,
+          chainKey,
+          client,
+          methodName: prop
+        });
+      };
+    }
+  });
+}
+function makeContractPendingTransaction(opts) {
+  const { txHash, abi, address, chainKey, client, methodName } = opts;
+  return {
+    txHash,
+    async wait(waitOpts) {
+      const receipt = await client.waitForReceipt(chainKey, txHash, {
+        timeoutMs: waitOpts?.timeoutMs
+      });
+      if (receipt.status === "0x0") {
+        throw new TwakError(
+          `Transaction reverted on-chain: ${receipt.transactionHash}`,
+          "TX_FAILED",
+          { txHash: receipt.transactionHash, methodName, receipt }
+        );
+      }
+      return {
+        txHash: receipt.transactionHash,
+        blockNumber: hexToSafeNumber(receipt.blockNumber, "blockNumber"),
+        events: extractEvents(abi, receipt.logs, address)
+      };
+    }
+  };
+}
+function extractEvents(abi, logs, contractAddress) {
+  const events = /* @__PURE__ */ Object.create(null);
+  for (const entry of abi) {
+    if (entry.type === "event") {
+      const name2 = entry.name;
+      if (typeof name2 === "string") events[name2] = [];
+    }
+  }
+  const lowerContract = contractAddress.toLowerCase();
+  for (const log of logs) {
+    if (log.address.toLowerCase() !== lowerContract) continue;
+    const decoded = decodeLog(abi, log);
+    if (!decoded) continue;
+    (events[decoded.eventName] ??= []).push(decoded.args);
+  }
+  return events;
+}
+function hexToSafeNumber(hex2, fieldName) {
+  let big;
+  try {
+    big = BigInt(hex2);
+  } catch {
+    throw new TwakValidationError(`Malformed hex for ${fieldName}: ${hex2}`, {
+      kind: "invalidHex",
+      fieldName
+    });
+  }
+  if (big > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new TwakValidationError(`${fieldName} exceeds safe integer range (${hex2})`, {
+      kind: "unsafeNumber",
+      fieldName
+    });
+  }
+  return Number(big);
+}
+function chainKeyToCaip2(chainKey) {
+  const def = requireChain(chainKey);
+  return `${def.namespace}:${def.chainId}`;
+}
+var JS_INTERNAL_PROPS = /* @__PURE__ */ new Set([
+  "then",
+  "toJSON",
+  "toString",
+  "inspect",
+  "constructor",
+  "Symbol(nodejs.util.inspect.custom)"
+]);
+function isJsInternal(prop) {
+  return JS_INTERNAL_PROPS.has(prop);
+}
+function defineContract(def) {
+  const { id, abi, addresses } = def;
+  return {
+    id,
+    abi,
+    using(client) {
+      return {
+        id,
+        abi,
+        withAddress(address, chainKey) {
+          return createContractInstance({ abi, address, chainKey, client });
+        },
+        bindAt(chainKey) {
+          const address = lookupAddress(id, addresses, chainKey);
+          return createContractInstance({ abi, address, chainKey, client });
+        },
+        resolve(opts) {
+          const address = opts.addressOverride ?? lookupAddress(id, addresses, opts.chainKey);
+          return createContractInstance({ abi, address, chainKey: opts.chainKey, client });
+        }
+      };
+    }
+  };
+}
+function lookupAddress(id, addresses, chainKey) {
+  if (!addresses) {
+    throw new TwakValidationError(
+      `Contract "${id}" has no address registry; use .withAddress(address, chainKey)`,
+      { kind: "noAddressRegistry", contractId: id, chainKey }
+    );
+  }
+  const address = addresses[chainKey];
+  if (!address) {
+    throw new TwakValidationError(
+      `Contract "${id}" has no address for chain "${chainKey}". Known: ${Object.keys(addresses).join(", ") || "(none)"}`,
+      { kind: "noAddressForChain", contractId: id, chainKey }
+    );
+  }
+  return address;
+}
+var ERC20_ABI = [
+  {
+    type: "function",
+    name: "transfer",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "approve",
+    inputs: [
+      { name: "spender", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable"
+  },
+  {
+    type: "function",
+    name: "allowance",
+    inputs: [
+      { name: "owner", type: "address" },
+      { name: "spender", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "function",
+    name: "balanceOf",
+    inputs: [{ name: "owner", type: "address" }],
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view"
+  },
+  {
+    type: "event",
+    name: "Transfer",
+    inputs: [
+      { name: "from", type: "address", indexed: true },
+      { name: "to", type: "address", indexed: true },
+      { name: "value", type: "uint256" }
+    ],
+    anonymous: false
+  },
+  {
+    type: "event",
+    name: "Approval",
+    inputs: [
+      { name: "owner", type: "address", indexed: true },
+      { name: "spender", type: "address", indexed: true },
+      { name: "value", type: "uint256" }
+    ],
+    anonymous: false
+  }
+];
+var erc20 = defineContract({ id: "erc20", abi: ERC20_ABI });
+
+// src/commands/swap.ts
 var MAX_SLIPPAGE_PCT = 50;
 var WARN_SLIPPAGE_PCT = 5;
 function registerSwapCommand(program3) {
@@ -41736,24 +42494,13 @@ function registerSwapCommand(program3) {
             const fromAssetAddr = firstStep.from.asset.address;
             const isNative = !fromAssetAddr || fromAssetAddr === NATIVE_TOKEN_ADDRESS;
             if (!isNative && chainConfig.coinId) {
-              const assetId = formatTokenId(chainConfig.coinId, fromAssetAddr);
               try {
-                const allowance = await blockchainClient.getAllowance({
-                  assetId,
-                  owner: walletAddress,
-                  spender: stepApproval.operatorAddress
-                });
+                const allowance = await blockchainClient.contract(erc20).withAddress(fromAssetAddr, fromChain).read.allowance([walletAddress, stepApproval.operatorAddress]);
                 const requiredAmount = BigInt(stepApproval.minAmount || parsedAmount);
                 if (allowance < requiredAmount) {
                   info("Sending token approval...");
-                  const hdWallet = provider.getSigner().getHDWallet();
-                  const approveResult = await blockchainClient.approve({
-                    assetId,
-                    spender: stepApproval.operatorAddress,
-                    amount: requiredAmount.toString(),
-                    hdWallet
-                  });
-                  info(`Approval tx: ${getExplorerTxUrl(fromChain, approveResult.hash)}`);
+                  const approveResult = await blockchainClient.contract(erc20).withAddress(fromAssetAddr, fromChain).write.approve([stepApproval.operatorAddress, requiredAmount], provider);
+                  info(`Approval tx: ${getExplorerTxUrl(fromChain, approveResult.txHash)}`);
                   const approvalDeadline = Date.now() + 6e4;
                   while (Date.now() < approvalDeadline) {
                     await new Promise((r3) => setTimeout(r3, 2e3));
@@ -41761,7 +42508,7 @@ function registerSwapCommand(program3) {
                       const status = await blockchainClient.findTransactionStatus(
                         fromChain,
                         walletAddress,
-                        approveResult.hash
+                        approveResult.txHash
                       );
                       if (status.confirmed) break;
                       if (status.failed)
@@ -41870,10 +42617,10 @@ function registerSwapCommand(program3) {
 
 // src/commands/erc20.ts
 init_dist();
-init_dist4();
+init_dist3();
 function registerErc20Command(program3) {
-  const erc20 = program3.command("erc20").description("ERC-20 token operations");
-  erc20.command("approve").description("Approve a spender for token spending").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address").requiredOption("--amount <n>", 'Amount to approve (in smallest unit, or "unlimited")').option(
+  const erc202 = program3.command("erc20").description("ERC-20 token operations");
+  erc202.command("approve").description("Approve a spender for token spending").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address").requiredOption("--amount <n>", 'Amount to approve (in smallest unit, or "unlimited")').option(
     "--password <password>",
     "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)"
   ).option(
@@ -41917,19 +42664,13 @@ function registerErc20Command(program3) {
       }
       info(`Approving ${opts.spender} to spend from ${address} on ${chainKey}...`);
       const client = provider.getBlockchainClient();
-      const hdWallet = provider.getSigner().getHDWallet();
-      const result = await client.approve({
-        assetId: opts.token,
-        spender: opts.spender,
-        amount,
-        hdWallet
-      });
-      const explorerUrl = getExplorerTxUrl(result.chainKey, result.hash);
+      const pending = await client.contract(erc20).withAddress(contractAddress, chainKey).write.approve([opts.spender, BigInt(amount)], provider);
+      const explorerUrl = getExplorerTxUrl(chainKey, pending.txHash);
       success("Approval sent!");
       output(
         {
-          hash: result.hash,
-          chain: result.chainKey,
+          hash: pending.txHash,
+          chain: chainKey,
           owner: address,
           spender: opts.spender,
           token: opts.token,
@@ -41943,7 +42684,7 @@ function registerErc20Command(program3) {
     }
     safeExit();
   });
-  erc20.command("revoke").description("Revoke token approval (set allowance to 0)").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address to revoke").option(
+  erc202.command("revoke").description("Revoke token approval (set allowance to 0)").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--spender <address>", "Spender address to revoke").option(
     "--password <password>",
     "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)"
   ).option("--json", "JSON output").action(async (opts) => {
@@ -41974,19 +42715,13 @@ function registerErc20Command(program3) {
       const address = await provider.getAddress(chainKey);
       info(`Revoking approval for ${opts.spender} on ${chainKey}...`);
       const client = provider.getBlockchainClient();
-      const hdWallet = provider.getSigner().getHDWallet();
-      const result = await client.approve({
-        assetId: opts.token,
-        spender: opts.spender,
-        amount: "0",
-        hdWallet
-      });
-      const explorerUrl = getExplorerTxUrl(result.chainKey, result.hash);
+      const pending = await client.contract(erc20).withAddress(contractAddress, chainKey).write.approve([opts.spender, 0n], provider);
+      const explorerUrl = getExplorerTxUrl(chainKey, pending.txHash);
       success("Approval revoked!");
       output(
         {
-          hash: result.hash,
-          chain: result.chainKey,
+          hash: pending.txHash,
+          chain: chainKey,
           owner: address,
           spender: opts.spender,
           token: opts.token,
@@ -41999,7 +42734,7 @@ function registerErc20Command(program3) {
     }
     safeExit();
   });
-  erc20.command("allowance").description("Check token allowance").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--owner <address>", "Owner address").requiredOption("--spender <address>", "Spender address").option("--json", "JSON output").action(async (opts) => {
+  erc202.command("allowance").description("Check token allowance").requiredOption("--token <assetId>", "Token asset ID (e.g., c60_t0xA0b8...)").requiredOption("--owner <address>", "Owner address").requiredOption("--spender <address>", "Spender address").option("--json", "JSON output").action(async (opts) => {
     try {
       await ensureTrustSDK();
       let coinId;
@@ -42019,10 +42754,10 @@ function registerErc20Command(program3) {
         );
       }
       try {
-        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports2));
-        const wc2 = getWalletCore2();
+        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+        const wc3 = getWalletCore2();
         const ct5 = getCoinType2(coinId);
-        if (ct5 && !wc2.CoinTypeExt.validate(ct5, contractAddress)) {
+        if (ct5 && !wc3.CoinTypeExt.validate(ct5, contractAddress)) {
           throw new Erc20Error(
             "VALIDATION_ERROR",
             `Invalid contract address in asset ID: ${contractAddress}`
@@ -42031,12 +42766,15 @@ function registerErc20Command(program3) {
       } catch (err) {
         if (err instanceof CommandError) throw err;
       }
+      const chainKey = coinTypeToChainKey(coinId);
+      if (!chainKey) {
+        throw new Erc20Error(
+          "CHAIN_UNSUPPORTED",
+          `Unsupported coin type in asset ID: ${opts.token}`
+        );
+      }
       const client = new BlockchainClient();
-      const allowance = await client.getAllowance({
-        assetId: opts.token,
-        owner: opts.owner,
-        spender: opts.spender
-      });
+      const allowance = await client.contract(erc20).withAddress(contractAddress, chainKey).read.allowance([opts.owner, opts.spender]);
       output(
         {
           token: opts.token,
@@ -42072,8 +42810,8 @@ async function resolveTokenLabel(tokenId, service) {
       const chainTokens = COMMON_TOKENS[chainKey];
       if (chainTokens) {
         const normalizedAddr = contractAddress.toLowerCase();
-        for (const [sym, addr] of Object.entries(chainTokens)) {
-          if (addr.toLowerCase() === normalizedAddr) {
+        for (const [sym, entry] of Object.entries(chainTokens)) {
+          if (entry.address.toLowerCase() === normalizedAddr) {
             await assetCache.set(tokenId, sym);
             return sym;
           }
@@ -42350,7 +43088,7 @@ var TransactionService = class {
 };
 
 // src/commands/query.ts
-init_dist4();
+init_dist3();
 var import_chalk7 = __toESM(require_source());
 function handleError(err, json) {
   handleCommandError(err, json ?? false, "Query failed");
@@ -42364,7 +43102,7 @@ function registerQueryCommand(program3) {
       const client = await getClient();
       const swapClient = new SwapClient(client);
       const tokens = token.split(",").map((t) => t.trim()).filter(Boolean);
-      const resolveChain = (t) => {
+      const resolveChain2 = (t) => {
         if (opts.chain) return opts.chain;
         if (Object.prototype.hasOwnProperty.call(CHAINS, t.toLowerCase())) return t.toLowerCase();
         const bySymbol = Object.entries(CHAINS).find(
@@ -42387,7 +43125,7 @@ function registerQueryCommand(program3) {
         const assetIds = [];
         const tokenMeta = [];
         for (const t of tokens) {
-          const chain3 = resolveChain(t);
+          const chain3 = resolveChain2(t);
           const info2 = resolveToken(t, chain3);
           if (!info2) {
             warn(`Unknown token: ${t.toUpperCase()}`);
@@ -42432,7 +43170,7 @@ function registerQueryCommand(program3) {
         }
         return;
       }
-      const chain2 = resolveChain(token);
+      const chain2 = resolveChain2(token);
       const tokenInfo = resolveToken(token, chain2);
       let price = null;
       if (tokenInfo) {
@@ -42695,10 +43433,10 @@ function registerQueryCommand(program3) {
       if (!chain2) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown coin ID: ${coinId}`);
       try {
         await ensureTrustSDK();
-        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports2));
-        const wc2 = getWalletCore2();
+        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+        const wc3 = getWalletCore2();
         const ct5 = getCoinType2(coinId);
-        if (ct5 && !wc2.CoinTypeExt.validate(ct5, opts.address)) {
+        if (ct5 && !wc3.CoinTypeExt.validate(ct5, opts.address)) {
           throw new QueryError("VALIDATION_ERROR", `Invalid address format for ${chain2.name}`);
         }
       } catch (err) {
@@ -42777,11 +43515,11 @@ function registerQueryCommand(program3) {
         const coinId = parseInt(coinIdStr, 10);
         try {
           await ensureTrustSDK();
-          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports2));
-          const wc2 = getWalletCore2();
+          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+          const wc3 = getWalletCore2();
           const ct5 = getCoinType2(coinId);
           if (ct5) {
-            const isValid = wc2.CoinTypeExt.validate(ct5, opts.address);
+            const isValid = wc3.CoinTypeExt.validate(ct5, opts.address);
             if (!isValid) {
               const chainInfo = getChainByCoinId(coinId);
               const label = chainInfo?.name ?? `coin ${coinId}`;
@@ -42940,6 +43678,7 @@ init_dist();
 var import_zod5 = require("zod");
 init_dist();
 var import_zod6 = require("zod");
+init_dist();
 var import_zod7 = require("zod");
 init_dist();
 var import_zod8 = require("zod");
@@ -42950,6 +43689,7 @@ var import_zod10 = require("zod");
 init_dist3();
 init_dist();
 var import_zod11 = require("zod");
+init_dist();
 var import_zod12 = require("zod");
 init_dist();
 var import_zod13 = require("zod");
@@ -43383,7 +44123,6 @@ async function payAndFetch(args) {
         blockchainClient: bc2,
         chainKey,
         chainId: evmChainId,
-        coinId: CHAINS[chainKey].coinId,
         owner: fromAddress,
         tokenAddress,
         requiredAmount: BigInt(amount),
@@ -43433,12 +44172,8 @@ async function payAndFetch(args) {
 }
 var MAX_UINT256_DECIMAL = (2n ** 256n - 1n).toString();
 async function ensurePermit2Allowance(args) {
-  const assetId = `c${args.coinId}_t${args.tokenAddress}`;
-  const allowance = await args.blockchainClient.getAllowance({
-    assetId,
-    owner: args.owner,
-    spender: PERMIT2_ADDRESS
-  });
+  const token = args.blockchainClient.contract(erc20).withAddress(args.tokenAddress, args.chainKey);
+  const allowance = await token.read.allowance([args.owner, PERMIT2_ADDRESS]);
   if (allowance >= args.requiredAmount) return null;
   const ctx = {
     token: args.tokenAddress,
@@ -43449,19 +44184,18 @@ async function ensurePermit2Allowance(args) {
   };
   const approved = await args.confirmApproval?.(ctx) === true;
   if (!approved) {
+    const assetId = formatTokenId(CHAINS[args.chainKey].coinId, args.tokenAddress);
     throw new X402Error(
       "PERMIT2_APPROVAL_REQUIRED",
-      `Permit2 needs a one-time approval for ${args.tokenAddress} on ${args.chainKey}. Run: twak erc20 approve --asset ${assetId} --spender ${PERMIT2_ADDRESS} --amount unlimited`
+      `Permit2 needs a one-time approval for ${args.tokenAddress} on ${args.chainKey}. Run: twak erc20 approve --token ${assetId} --spender ${PERMIT2_ADDRESS} --amount unlimited`
     );
   }
-  const { txHash } = await args.walletProvider.approveErc20(
-    args.chainKey,
-    args.tokenAddress,
-    PERMIT2_ADDRESS,
-    MAX_UINT256_DECIMAL
+  const pending = await token.write.approve(
+    [PERMIT2_ADDRESS, BigInt(MAX_UINT256_DECIMAL)],
+    args.walletProvider
   );
-  await waitForTxConfirmation(args.blockchainClient, args.chainKey, args.owner, txHash);
-  return { token: args.tokenAddress, chain: args.chainKey, txHash };
+  await waitForTxConfirmation(args.blockchainClient, args.chainKey, args.owner, pending.txHash);
+  return { token: args.tokenAddress, chain: args.chainKey, txHash: pending.txHash };
 }
 var APPROVE_TIMEOUT_MS = 6e4;
 var APPROVE_POLL_MS = 2e3;
@@ -43812,6 +44546,8 @@ var ActionRegistry = class {
     return this.providers;
   }
 };
+var CHAIN_DESC = 'Chain (e.g., "ethereum", "bsc", "solana"). Accepts chain key, CAIP-2 ("eip155:1"), EVM chainId ("56", "0x38"), aliases ("matic", "op"), and asset IDs ("c60").';
+var TOKEN_ADDR_DESC = "Token contract address (ERC-20 / SPL). Omit for the chain native coin (ETH, BNB, SOL, etc.).";
 var BalanceActionProvider = class extends ActionProvider {
   name = "balance";
   description = "Check token balances and holdings";
@@ -43821,25 +44557,14 @@ var BalanceActionProvider = class extends ActionProvider {
   getBalance() {
     return {
       name: "get_balance",
-      description: 'Read the on-chain balance of a single asset for a wallet address. Pass `chainKey` as one of the supported chain keys: "ethereum", "bsc", "base", "polygon", "arbitrum", "optimism", "avalanche", "fantom", "linea", "scroll", "zksync", "blast", "sonic", "celo", "aurora", "solana", "bitcoin", "litecoin", "dogecoin", "tron", "cosmos", "near", "aptos", "ton", "sui". Omit `tokenAddress` for the chain\'s native coin (ETH, BNB, SOL, BTC, ...). Provide `tokenAddress` to read an ERC-20 / SPL token (e.g. tokenAddress="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" with chainKey="base" for USDC on Base; tokenAddress="0x55d398326f99059fF775485246999027B3197955" with chainKey="bsc" for USDT on BSC).',
+      description: 'Read the on-chain balance of a single asset for a wallet address. Omit `tokenAddress` for the chain native coin (ETH, BNB, SOL, BTC, ...). Provide `tokenAddress` to read an ERC-20 / SPL token (e.g. tokenAddress="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913" with chain="base" for USDC on Base).',
       schema: import_zod3.z.object({
         address: import_zod3.z.string().describe("Wallet address on the specified chain."),
-        chainKey: import_zod3.z.string().describe(
-          'Chain key (e.g. "ethereum", "bsc", "base", "polygon", "solana"). Lowercase, no spaces. See the action description for the full supported list.'
-        ),
-        tokenAddress: import_zod3.z.string().trim().min(1).optional().describe(
-          "Optional. ERC-20 or SPL token contract address on the chosen chain. Omit (or pass undefined) to read the chain's native coin balance. Empty or whitespace-only strings are rejected."
-        )
+        chain: import_zod3.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod3.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC)
       }),
       invoke: async (ctx, input2) => {
-        const coinId = chainKeyToCoinType(input2.chainKey);
-        if (coinId === void 0) {
-          throw new WalletError(
-            "CHAIN_UNSUPPORTED",
-            `Unsupported chain: "${input2.chainKey}". Supported keys include "ethereum", "bsc", "base", "polygon", "arbitrum", "optimism", "avalanche", "solana", "bitcoin" and others.`
-          );
-        }
-        const assetId = formatTokenId(coinId, input2.tokenAddress);
+        const { assetId } = resolveAsset(input2.chain, input2.tokenAddress);
         return fetchBalance(ctx.httpClient, assetId, input2.address);
       }
     };
@@ -43847,26 +44572,32 @@ var BalanceActionProvider = class extends ActionProvider {
   getTokenHoldings() {
     return {
       name: "get_token_holdings",
-      description: "Get ERC-20 token holdings for an address",
+      description: "Get ERC-20 / SPL token holdings for a wallet address on a chain. Returns the list of tokens the address holds. Omit `tokenAddress` to list all token holdings on the chain.",
       schema: import_zod3.z.object({
-        address: import_zod3.z.string().describe("Wallet address"),
-        coin: import_zod3.z.coerce.number().describe("SLIP44 coin ID")
+        address: import_zod3.z.string().describe("Wallet address on the specified chain."),
+        chain: import_zod3.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod3.z.string().trim().min(1).optional().describe(
+          "Token contract address (ERC-20 / SPL). Omit to list all token holdings on the chain; provide an address to filter to that single token."
+        )
       }),
       invoke: async (ctx, input2) => {
+        const { chainKey, coinId } = resolveAsset(input2.chain);
         const response = await ctx.httpClient.gateway(
           "POST",
           "/v1/assets",
           {
             version: 2,
             includeDisabledAssets: false,
-            assets: [{ address: input2.address, coin: input2.coin }]
+            assets: [{ address: input2.address, coin: coinId }]
           }
         );
         const holdings = Array.isArray(response) ? response : response.docs ?? response.data ?? [];
+        const tokenFilter = input2.tokenAddress?.toLowerCase();
         const tokens = [];
         for (const h4 of holdings) {
           if (Array.isArray(h4.tokens)) {
             for (const t of h4.tokens) {
+              if (tokenFilter && String(t.contract).toLowerCase() !== tokenFilter) continue;
               tokens.push({
                 symbol: t.symbol ?? t.contract,
                 contract: t.contract,
@@ -43878,7 +44609,7 @@ var BalanceActionProvider = class extends ActionProvider {
             }
           }
         }
-        return { address: input2.address, coin: input2.coin, tokens };
+        return { address: input2.address, chain: chainKey, tokens };
       }
     };
   }
@@ -43888,7 +44619,9 @@ var BalanceActionProvider = class extends ActionProvider {
       description: "Search for tokens by name, symbol, or address",
       schema: import_zod3.z.object({
         query: import_zod3.z.string().describe("Search query"),
-        networks: import_zod3.z.string().optional().describe("Comma-separated coin IDs to filter"),
+        chains: import_zod3.z.string().optional().describe(
+          `Comma-separated list of chains to restrict the search. Each entry accepts the same forms as the canonical \`chain\` input. ${CHAIN_DESC}`
+        ),
         limit: import_zod3.z.coerce.number().optional().default(10).describe("Max results")
       }),
       invoke: async (ctx, input2) => {
@@ -43898,52 +44631,41 @@ var BalanceActionProvider = class extends ActionProvider {
           version: "24",
           limit: (input2.limit || 10).toString()
         });
-        if (input2.networks) params.set("networks", input2.networks);
+        const chainsInput = input2.chains;
+        if (chainsInput) {
+          const coinIds = chainsInput.split(",").map((c3) => c3.trim()).filter((c3) => c3.length > 0).map((c3) => resolveAsset(c3).coinId.toString()).join(",");
+          if (coinIds) params.set("networks", coinIds);
+        }
         return ctx.httpClient.gateway("GET", "/v1/search/assets", void 0, params.toString());
       }
     };
   }
 };
-var ERC20_TRANSFER_SIG = "0xa9059cbb";
 var NATIVE_TOKEN_PLACEHOLDER = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 var DEFAULT_MAX_TRANSFER_USD2 = 1e4;
-function encodeErc20Transfer(to3, amount) {
-  const paddedTo = to3.slice(2).padStart(64, "0");
-  const paddedAmount = amount.toString(16).padStart(64, "0");
-  return `${ERC20_TRANSFER_SIG}${paddedTo}${paddedAmount}`;
-}
-function extractEvmChainId(chainId) {
-  if (chainId.startsWith("eip155:")) return chainId.split(":")[1];
-  return chainId;
-}
-function toCaip2(chain2) {
-  let caip2;
-  if (chain2.includes(":")) {
-    caip2 = chain2;
-  } else {
-    const def = getChainById(chain2);
-    if (!def) {
-      throw new TransferError(
-        "CHAIN_UNSUPPORTED",
-        `Unknown chain: ${chain2}. Use a chain key like ethereum, bsc, polygon, arbitrum, optimism, base, or a CAIP-2 id like eip155:1.`
-      );
-    }
-    caip2 = `${def.namespace}:${def.chainId}`;
-  }
-  if (!caip2.startsWith("eip155:")) {
+function resolveEvmChain(chain2) {
+  const chainKey = resolveChain(chain2);
+  const def = requireChain(chainKey);
+  if (def.namespace !== "eip155") {
     throw new TransferError(
       "CHAIN_UNSUPPORTED",
-      `Transfer is only supported for EVM chains (eip155:*). Got: ${chain2}`
+      `Transfer is only supported for EVM chains. Got: ${chain2}`
     );
   }
-  return caip2;
+  return { chainKey, caip2: `eip155:${def.chainId}` };
 }
 var TransferActionProvider = class extends ActionProvider {
-  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_TRANSFER_USD2) {
+  // `blockchainClient` is the 4th (optional) arg, not the 1st, to avoid
+  // churning the ~14 existing test sites that already pass only walletContext
+  // (+ optional priceLookup / maxTransferUsd). TokenActionProvider uses
+  // blockchainClient as its 1st arg — that asymmetry is intentional for this
+  // PR; normalize in a follow-up once the integration branch settles.
+  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_TRANSFER_USD2, blockchainClient) {
     super();
     this.walletContext = walletContext;
     this.priceLookup = priceLookup;
     this.maxTransferUsd = maxTransferUsd;
+    this.blockchainClient = blockchainClient;
   }
   name = "transfer";
   description = "Transfer tokens to another address";
@@ -43955,24 +44677,28 @@ var TransferActionProvider = class extends ActionProvider {
       name: "transfer",
       description: 'Transfer native or ERC-20 tokens to a destination address on any EVM chain. Resolves ENS for the "to" field, applies a USD safety cap, and works with both the local agent wallet and an external WalletConnect-paired wallet.',
       schema: import_zod4.z.object({
-        chain: import_zod4.z.string().describe(
-          'Chain name (e.g., ethereum, bsc, polygon, arbitrum, base). CAIP-2 ids like "eip155:1" also accepted.'
-        ),
+        chain: import_zod4.z.string().describe(CHAIN_DESC),
         to: import_zod4.z.string().describe("Destination address or ENS name (e.g., vitalik.eth)"),
         amount: import_zod4.z.string().describe('Amount in human-readable format (e.g., "1.5", "0.01")'),
-        token: import_zod4.z.string().optional().describe("ERC-20 token contract address (omit for native token)"),
-        decimals: import_zod4.z.coerce.number().optional().default(18).describe("Token decimals (default 18, use 6 for USDC/USDT)")
+        tokenAddress: import_zod4.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
+        decimals: import_zod4.z.coerce.number().int().min(0).max(36).optional().describe(
+          "Token decimals (non-negative integer). Omit for native coins and for tokens twak recognizes \u2014 decimals are derived from `COMMON_TOKENS` per chain (BSC stables are 18, USDC on Ethereum is 6, etc.). REQUIRED when tokenAddress is a contract twak does not recognize; look up the value on the token contract."
+        )
       }),
       invoke: async (_ctx, input2) => {
         const signer = this.walletContext.activeWallet();
-        const caip2 = toCaip2(input2.chain);
+        const { chainKey, caip2 } = resolveEvmChain(input2.chain);
+        const tokenAddress = input2.tokenAddress?.toLowerCase() === NATIVE_TOKEN_PLACEHOLDER.toLowerCase() ? void 0 : input2.tokenAddress;
+        const decimals = input2.decimals ?? lookupKnownTokenDecimals(chainKey, tokenAddress);
+        if (decimals === void 0) {
+          throw new TransferError(
+            "VALIDATION_ERROR",
+            `Cannot derive decimals for ${tokenAddress} on ${chainKey}. Provide \`decimals\` explicitly.`
+          );
+        }
         if (this.priceLookup) {
           try {
-            const evmId2 = extractEvmChainId(caip2);
-            const chain22 = getChainById(evmId2) ?? getChainByEvmId(evmId2);
-            const chainKey = chain22 ? coinTypeToChainKey(chain22.coinId) ?? evmId2 : caip2;
-            const tokenAddress = input2.token || "";
-            const price = await this.priceLookup.getTokenPrice(chainKey, tokenAddress);
+            const price = await this.priceLookup.getTokenPrice(chainKey, tokenAddress ?? "");
             if (price && price > 0) {
               const usdValue = parseFloat(input2.amount) * price;
               if (usdValue > this.maxTransferUsd) {
@@ -43987,18 +44713,18 @@ var TransferActionProvider = class extends ActionProvider {
           }
         }
         const resolvedTo = await resolveAddressOrName(input2.to);
-        const atomicAmount = parseAmount(input2.amount, input2.decimals ?? 18);
-        const isErc20 = input2.token && input2.token !== NATIVE_TOKEN_PLACEHOLDER;
+        const atomicAmount = parseAmount(input2.amount, decimals);
+        const isErc20 = Boolean(tokenAddress);
         let txHash;
-        const evmId = extractEvmChainId(caip2);
         if (isErc20) {
-          const calldata = encodeErc20Transfer(resolvedTo, BigInt(atomicAmount));
-          txHash = await signer.sendTransaction({
-            chainId: caip2,
-            to: input2.token,
-            data: calldata,
-            value: "0x0"
-          });
+          if (!this.blockchainClient) {
+            throw new TransferError(
+              "WALLET_NOT_FOUND",
+              "BlockchainClient not available \u2014 ERC-20 transfer requires a configured blockchain client"
+            );
+          }
+          const pending = await this.blockchainClient.contract(erc20).withAddress(tokenAddress, chainKey).write.transfer([resolvedTo, BigInt(atomicAmount)], signer);
+          txHash = pending.txHash;
         } else {
           txHash = await signer.sendTransaction({
             chainId: caip2,
@@ -44007,8 +44733,7 @@ var TransferActionProvider = class extends ActionProvider {
             value: "0x" + BigInt(atomicAmount).toString(16)
           });
         }
-        const chain2 = getChainByEvmId(evmId);
-        const explorerUrl = getExplorerTxUrl(chain2?.id ?? caip2, txHash);
+        const explorerUrl = getExplorerTxUrl(chainKey, txHash);
         return {
           success: true,
           txHash,
@@ -44077,9 +44802,9 @@ var SwapActionProvider = class extends ActionProvider {
       name: "swap",
       description: "Execute a token swap via Trust Wallet (supports all chains including cross-chain)",
       schema: import_zod5.z.object({
-        fromChain: import_zod5.z.string().describe("Source chain (e.g., ethereum, polygon, solana)"),
+        fromChain: import_zod5.z.string().describe(`Source chain. ${CHAIN_DESC}`),
         fromToken: import_zod5.z.string().describe("Source token symbol or address"),
-        toChain: import_zod5.z.string().describe("Destination chain"),
+        toChain: import_zod5.z.string().describe(`Destination chain. ${CHAIN_DESC}`),
         toToken: import_zod5.z.string().describe("Destination token symbol or address"),
         amount: import_zod5.z.string().describe("Human-readable amount to swap"),
         slippage: import_zod5.z.string().optional().default("1").describe("Slippage tolerance % (max 50)")
@@ -44089,6 +44814,8 @@ var SwapActionProvider = class extends ActionProvider {
           throw new SwapError("WALLET_NOT_FOUND", "Swap client not configured");
         }
         const signer = this.walletContext.activeWallet();
+        const fromChain = resolveChain(input2.fromChain);
+        const toChain = resolveChain(input2.toChain);
         const slippage = parseFloat(input2.slippage ?? "1");
         if (isNaN(slippage) || slippage <= 0 || slippage > 50) {
           return {
@@ -44097,28 +44824,28 @@ var SwapActionProvider = class extends ActionProvider {
             message: `Slippage must be greater than 0% and at most 50%. Got: ${input2.slippage}`
           };
         }
-        const fromTokenInfo = resolveToken(input2.fromToken, input2.fromChain);
+        const fromTokenInfo = resolveToken(input2.fromToken, fromChain);
         if (!fromTokenInfo) {
           return {
             success: false,
             code: "TOKEN_NOT_FOUND",
-            message: `Unknown token: ${input2.fromToken} on ${input2.fromChain}`
+            message: `Unknown token: ${input2.fromToken} on ${fromChain}`
           };
         }
-        const toTokenInfo = resolveToken(input2.toToken, input2.toChain);
+        const toTokenInfo = resolveToken(input2.toToken, toChain);
         if (!toTokenInfo) {
           return {
             success: false,
             code: "TOKEN_NOT_FOUND",
-            message: `Unknown token: ${input2.toToken} on ${input2.toChain}`
+            message: `Unknown token: ${input2.toToken} on ${toChain}`
           };
         }
         const parsedAmount = parseAmount(input2.amount, fromTokenInfo.decimals);
-        const address = await signer.getAddress(input2.fromChain);
+        const address = await signer.getAddress(fromChain);
         const quote = await this.swapClient.getQuote({
-          fromChain: input2.fromChain,
+          fromChain,
           fromToken: fromTokenInfo.address,
-          toChain: input2.toChain,
+          toChain,
           toToken: toTokenInfo.address,
           amount: parsedAmount,
           walletAddress: address,
@@ -44128,18 +44855,13 @@ var SwapActionProvider = class extends ActionProvider {
           return { success: false, code: "NO_ROUTES", message: "No swap routes found" };
         }
         const route = quote.routes[0];
-        const chainConfig = getChainById(input2.fromChain);
+        const chainConfig = getChainById(fromChain);
         const transactions = await this.swapClient.getSwapTransactions(route);
         let txHash = "";
         for (const txData of transactions) {
           txHash = await this.sendSwapTx(txData, chainConfig, signer);
           const isApproval = txData.transaction.type === "approval" || txData.transaction.type === "revokeApproval";
-          await this.pollConfirmation(
-            input2.fromChain,
-            address,
-            txHash,
-            isApproval ? 6e4 : 12e4
-          );
+          await this.pollConfirmation(fromChain, address, txHash, isApproval ? 6e4 : 12e4);
         }
         const firstStep = route.steps[0];
         const lastStep = route.steps[route.steps.length - 1];
@@ -44148,7 +44870,7 @@ var SwapActionProvider = class extends ActionProvider {
           firstStep.from.asset.metadata.decimals
         );
         const outputAmt = formatAmount(lastStep.to.amount, lastStep.to.asset.metadata.decimals);
-        const explorerUrl = getExplorerTxUrl(input2.fromChain, txHash);
+        const explorerUrl = getExplorerTxUrl(fromChain, txHash);
         return {
           success: true,
           txHash,
@@ -44164,9 +44886,9 @@ var SwapActionProvider = class extends ActionProvider {
       name: "get_swap_quote",
       description: "Get a swap quote without executing",
       schema: import_zod5.z.object({
-        fromChain: import_zod5.z.string().describe("Source chain"),
+        fromChain: import_zod5.z.string().describe(`Source chain. ${CHAIN_DESC}`),
         fromToken: import_zod5.z.string().describe("Source token symbol or address"),
-        toChain: import_zod5.z.string().describe("Destination chain"),
+        toChain: import_zod5.z.string().describe(`Destination chain. ${CHAIN_DESC}`),
         toToken: import_zod5.z.string().describe("Destination token symbol or address"),
         amount: import_zod5.z.string().describe("Human-readable amount")
       }),
@@ -44174,30 +44896,32 @@ var SwapActionProvider = class extends ActionProvider {
         if (!this.swapClient) {
           throw new SwapError("WALLET_NOT_FOUND", "Swap client required");
         }
-        const fromTokenInfo = resolveToken(input2.fromToken, input2.fromChain);
+        const fromChain = resolveChain(input2.fromChain);
+        const toChain = resolveChain(input2.toChain);
+        const fromTokenInfo = resolveToken(input2.fromToken, fromChain);
         if (!fromTokenInfo) {
           return {
             success: false,
             code: "TOKEN_NOT_FOUND",
-            message: `Unknown token: ${input2.fromToken} on ${input2.fromChain}`
+            message: `Unknown token: ${input2.fromToken} on ${fromChain}`
           };
         }
-        const toTokenInfo = resolveToken(input2.toToken, input2.toChain);
+        const toTokenInfo = resolveToken(input2.toToken, toChain);
         if (!toTokenInfo) {
           return {
             success: false,
             code: "TOKEN_NOT_FOUND",
-            message: `Unknown token: ${input2.toToken} on ${input2.toChain}`
+            message: `Unknown token: ${input2.toToken} on ${toChain}`
           };
         }
         const parsedAmount = parseAmount(input2.amount, fromTokenInfo.decimals);
         const quote = await this.swapClient.getQuote({
-          fromChain: input2.fromChain,
+          fromChain,
           fromToken: fromTokenInfo.address,
-          toChain: input2.toChain,
+          toChain,
           toToken: toTokenInfo.address,
           amount: parsedAmount,
-          walletAddress: getSampleAccount(input2.fromChain)
+          walletAddress: getSampleAccount(fromChain)
         });
         if (quote.routes.length === 0) {
           return { success: false, code: "NO_ROUTES", message: "No routes found" };
@@ -44222,22 +44946,23 @@ var SwapActionProvider = class extends ActionProvider {
       name: "get_token_price",
       description: "Get current USD price for a token",
       schema: import_zod5.z.object({
-        chain: import_zod5.z.string().describe("Chain name (e.g., ethereum)"),
+        chain: import_zod5.z.string().describe(CHAIN_DESC),
         token: import_zod5.z.string().describe("Token symbol or address")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.swapClient) {
           throw new SwapError("WALLET_NOT_FOUND", "Swap client required");
         }
-        const tokenInfo = resolveToken(input2.token, input2.chain);
+        const chain2 = resolveChain(input2.chain);
+        const tokenInfo = resolveToken(input2.token, chain2);
         if (!tokenInfo) {
           return {
             success: false,
             code: "TOKEN_NOT_FOUND",
-            message: `Unknown token: ${input2.token} on ${input2.chain}`
+            message: `Unknown token: ${input2.token} on ${chain2}`
           };
         }
-        const price = await this.swapClient.getTokenPrice(input2.chain, tokenInfo.address);
+        const price = await this.swapClient.getTokenPrice(chain2, tokenInfo.address);
         if (price === null) {
           return {
             success: false,
@@ -44248,7 +44973,7 @@ var SwapActionProvider = class extends ActionProvider {
         return {
           success: true,
           token: input2.token.toUpperCase(),
-          chain: input2.chain,
+          chain: chain2,
           priceUsd: price
         };
       }
@@ -44271,26 +44996,37 @@ var SecurityActionProvider = class extends ActionProvider {
   validateTransaction() {
     return {
       name: "validate_transaction",
-      description: "Validate an address or transaction for security",
+      description: "Validate an address or transaction for security. Provide `chain` (and optional `tokenAddress`) to scope the validation to a specific asset; omit both for a generic address check.",
       schema: import_zod6.z.object({
         address: import_zod6.z.string().describe("Address to validate"),
-        assetId: import_zod6.z.string().optional().describe("Asset ID"),
+        chain: import_zod6.z.string().optional().describe(CHAIN_DESC),
+        tokenAddress: import_zod6.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         type: import_zod6.z.string().optional().describe("Validation type")
+      }).refine((data) => data.tokenAddress === void 0 || data.chain !== void 0, {
+        path: ["tokenAddress"],
+        message: "tokenAddress requires chain to be provided."
       }),
       invoke: async (ctx, input2) => {
-        return this.getService(ctx).validate(input2);
+        const assetId = input2.chain !== void 0 ? resolveAsset(input2.chain, input2.tokenAddress).assetId : void 0;
+        return this.getService(ctx).validate({
+          address: input2.address,
+          assetId,
+          type: input2.type
+        });
       }
     };
   }
   getAssetInfo() {
     return {
       name: "get_asset_info",
-      description: "Get detailed information about an asset",
+      description: "Get detailed information about an asset (name, symbol, price, market cap). Omit `tokenAddress` for the chain native coin.",
       schema: import_zod6.z.object({
-        assetId: import_zod6.z.string().describe("Asset ID (e.g., c60_t0xA0b8...)")
+        chain: import_zod6.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod6.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC)
       }),
       invoke: async (ctx, input2) => {
-        return this.getService(ctx).getAssetInfo(input2.assetId);
+        const { assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        return this.getService(ctx).getAssetInfo(assetId);
       }
     };
   }
@@ -44314,13 +45050,14 @@ var HistoryActionProvider = class extends ActionProvider {
       description: "Get transaction history for an address",
       schema: import_zod7.z.object({
         address: import_zod7.z.string().describe("Wallet address"),
-        chain: import_zod7.z.string().optional().describe("Chain name"),
+        chain: import_zod7.z.string().optional().describe(CHAIN_DESC),
         limit: import_zod7.z.coerce.number().optional().default(20).describe("Max results"),
         from: import_zod7.z.string().optional().describe("Start date (ISO)"),
         to: import_zod7.z.string().optional().describe("End date (ISO)")
       }),
       invoke: async (ctx, input2) => {
-        return this.getService(ctx).getHistory(input2);
+        const chain2 = input2.chain !== void 0 ? resolveChain(input2.chain) : void 0;
+        return this.getService(ctx).getHistory({ ...input2, chain: chain2 });
       }
     };
   }
@@ -44330,11 +45067,12 @@ var HistoryActionProvider = class extends ActionProvider {
       description: "Get details of a specific transaction by hash",
       schema: import_zod7.z.object({
         hash: import_zod7.z.string().describe("Transaction hash"),
-        chain: import_zod7.z.string().describe("Chain name")
+        chain: import_zod7.z.string().describe(CHAIN_DESC)
       }),
       invoke: async (ctx, input2) => {
-        const details = await this.getService(ctx).getByHash(input2.hash, input2.chain);
-        const explorer = getExplorerTxUrl(input2.chain, input2.hash);
+        const chain2 = resolveChain(input2.chain);
+        const details = await this.getService(ctx).getByHash(input2.hash, chain2);
+        const explorer = getExplorerTxUrl(chain2, input2.hash);
         return { ...details, explorer: explorer || void 0 };
       }
     };
@@ -44345,11 +45083,12 @@ var HistoryActionProvider = class extends ActionProvider {
       description: "Get swap transaction history",
       schema: import_zod7.z.object({
         address: import_zod7.z.string().describe("Wallet address"),
-        chain: import_zod7.z.string().optional().describe("Chain name"),
+        chain: import_zod7.z.string().optional().describe(CHAIN_DESC),
         limit: import_zod7.z.coerce.number().optional().default(20).describe("Max results")
       }),
       invoke: async (ctx, input2) => {
-        return this.getService(ctx).getSwapHistory(input2);
+        const chain2 = input2.chain !== void 0 ? resolveChain(input2.chain) : void 0;
+        return this.getService(ctx).getSwapHistory({ ...input2, chain: chain2 });
       }
     };
   }
@@ -44365,38 +45104,30 @@ var AlertActionProvider = class extends ActionProvider {
     this.swapClient = swapClient;
   }
   getActions() {
-    return [
-      this.createAlert(),
-      this.listAlerts(),
-      this.checkAlerts(),
-      this.deleteAlert()
-    ];
+    return [this.createAlert(), this.listAlerts(), this.checkAlerts(), this.deleteAlert()];
   }
   createAlert() {
     return {
       name: "create_alert",
-      description: "Create a price alert for a token. Triggers when price goes above or below a target.",
+      description: "Create a price alert. Triggers when the asset price crosses a target. Omit `tokenAddress` to watch the chain native coin (ETH, BNB, SOL, etc.).",
       schema: import_zod8.z.object({
-        tokenId: import_zod8.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
-        chainKey: import_zod8.z.string().describe('Chain key (e.g., "ethereum", "bsc")'),
+        chain: import_zod8.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod8.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         condition: import_zod8.z.enum(["above", "below"]).describe("Alert when price goes above or below target"),
         targetPrice: import_zod8.z.coerce.number().positive().describe("Target price in USD")
       }),
       invoke: async (_ctx, input2) => {
-        try {
-          parseTokenId(input2.tokenId);
-        } catch {
-          return { error: `Invalid tokenId format: ${input2.tokenId}. Expected format: "c60" or "c60_t0xABC..."` };
-        }
+        const { chainKey, assetId: tokenId } = resolveAsset(input2.chain, input2.tokenAddress);
         const alert = await this.alertStore.create({
-          tokenId: input2.tokenId,
-          chainKey: input2.chainKey,
+          tokenId,
+          chainKey,
           condition: input2.condition,
           targetPrice: input2.targetPrice
         });
+        const label = input2.tokenAddress ? `${input2.tokenAddress} on ${chainKey}` : `${requireChain(chainKey).symbol} on ${chainKey}`;
         return {
           id: alert.id,
-          message: `Alert created: notify when ${input2.tokenId} goes ${input2.condition} $${input2.targetPrice}`
+          message: `Alert created: notify when ${label} goes ${input2.condition} $${input2.targetPrice}`
         };
       }
     };
@@ -44425,10 +45156,7 @@ var AlertActionProvider = class extends ActionProvider {
         for (const alert of activeAlerts) {
           if (!this.swapClient) continue;
           const { contractAddress } = parseTokenId(alert.tokenId);
-          const price = await this.swapClient.getTokenPrice(
-            alert.chainKey,
-            contractAddress || ""
-          );
+          const price = await this.swapClient.getTokenPrice(alert.chainKey, contractAddress || "");
           if (price === null) continue;
           const shouldTrigger = alert.condition === "above" && price >= alert.targetPrice || alert.condition === "below" && price <= alert.targetPrice;
           if (shouldTrigger) {
@@ -44483,12 +45211,13 @@ var AgentWalletActionProvider = class extends ActionProvider {
       name: "get_address",
       description: "Get the active wallet's address for a specific chain.",
       schema: import_zod9.z.object({
-        chainKey: import_zod9.z.string().describe('Chain key (e.g., "ethereum", "bsc", "solana")')
+        chain: import_zod9.z.string().describe(CHAIN_DESC)
       }),
       invoke: async (_ctx, input2) => {
+        const chainKey = resolveChain(input2.chain);
         const wallet = this.requireWallet();
-        const address = await wallet.getAddress(input2.chainKey);
-        return { chainKey: input2.chainKey, address };
+        const address = await wallet.getAddress(chainKey);
+        return { chain: chainKey, address };
       }
     };
   }
@@ -44509,21 +45238,17 @@ var AgentWalletActionProvider = class extends ActionProvider {
       name: "wallet_balance",
       description: "Read the native-coin balance (BNB on BSC, ETH on Ethereum / Base / Arbitrum, SOL on Solana, etc.) for the active wallet on a specific chain. For ERC-20 / SPL token balances, use `get_balance`.",
       schema: import_zod9.z.object({
-        chainKey: import_zod9.z.string().describe('Chain key (e.g., "ethereum", "bsc")')
+        chain: import_zod9.z.string().describe(CHAIN_DESC)
       }),
       invoke: async (_ctx, input2) => {
+        const { chainKey, assetId } = resolveAsset(input2.chain);
         const wallet = this.requireWallet();
-        const address = await wallet.getAddress(input2.chainKey);
+        const address = await wallet.getAddress(chainKey);
         if (!this.blockchainClient) {
-          return { chainKey: input2.chainKey, address, balance: "BlockchainClient not available" };
+          return { chain: chainKey, address, balance: "BlockchainClient not available" };
         }
-        const coinType = chainKeyToCoinType(input2.chainKey);
-        if (coinType === void 0) {
-          throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported chain: ${input2.chainKey}`);
-        }
-        const assetId = formatTokenId(coinType);
         const balance = await this.blockchainClient.getBalance(assetId, address);
-        return { chainKey: input2.chainKey, address, balance };
+        return { chain: chainKey, address, balance };
       }
     };
   }
@@ -44548,17 +45273,19 @@ var TokenActionProvider = class extends ActionProvider {
   tokenBalance() {
     return {
       name: "token_balance",
-      description: "Get balance for a specific token or native asset by asset ID",
+      description: "Get balance for a specific token or native asset on a chain.",
       schema: import_zod10.z.object({
-        assetId: import_zod10.z.string().describe('Token ID (e.g., "c60" for ETH, "c20000714_t0x55d3..." for BSC USDT)'),
+        chain: import_zod10.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod10.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         address: import_zod10.z.string().describe("Wallet address to check balance for")
       }),
       invoke: async (_ctx, input2) => {
         if (!this.blockchainClient) {
           throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
         }
-        const balance = await this.blockchainClient.getBalance(input2.assetId, input2.address);
-        return { assetId: input2.assetId, address: input2.address, balance };
+        const { chainKey, assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        const balance = await this.blockchainClient.getBalance(assetId, input2.address);
+        return { chain: chainKey, address: input2.address, balance };
       }
     };
   }
@@ -44567,54 +45294,60 @@ var TokenActionProvider = class extends ActionProvider {
       name: "transfer_token",
       description: "Transfer a token or native asset to a destination address. Works in both local and WalletConnect modes for EVM chains; non-EVM chains (e.g. Solana) require local wallet mode.",
       schema: import_zod10.z.object({
-        assetId: import_zod10.z.string().describe("Token ID to transfer"),
+        chain: import_zod10.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod10.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         to: import_zod10.z.string().describe("Destination address"),
-        amount: import_zod10.z.string().describe("Amount to transfer (in smallest unit)"),
+        amount: import_zod10.z.string().describe('Amount in human-readable format (e.g., "1.5", "0.01")'),
+        decimals: import_zod10.z.coerce.number().int().min(0).max(36).optional().describe(
+          "Token decimals (non-negative integer). Omit for native coins and for tokens twak recognizes \u2014 decimals are derived from `COMMON_TOKENS` per chain (BSC stables are 18, USDC on Ethereum is 6, etc.). REQUIRED when tokenAddress is a contract twak does not recognize; look up the value on the token contract."
+        ),
         memo: import_zod10.z.string().optional().describe("Optional memo/note")
       }),
       invoke: async (_ctx, input2) => {
         const wallet = this.walletContext.activeWallet();
+        const { chainKey, assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        const decimals = input2.decimals ?? lookupKnownTokenDecimals(chainKey, input2.tokenAddress);
+        if (decimals === void 0) {
+          throw new WalletError(
+            "VALIDATION_ERROR",
+            `Cannot derive decimals for ${input2.tokenAddress} on ${chainKey}. Provide \`decimals\` explicitly.`
+          );
+        }
         if (wallet instanceof AgentWalletProvider) {
           if (!this.blockchainClient) {
             throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
           }
           const hdWallet = wallet.getSigner().getHDWallet();
           const result = await this.blockchainClient.transfer({
-            assetId: input2.assetId,
+            assetId,
             to: input2.to,
             amount: input2.amount,
+            decimals,
             memo: input2.memo,
             hdWallet
           });
-          return { hash: result.hash, chainKey: result.chainKey };
-        }
-        const { coinId, contractAddress } = parseTokenId(input2.assetId);
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) {
-          throw new WalletError("CHAIN_UNSUPPORTED", `Unknown coin type: ${coinId}`);
+          return { hash: result.txHash, chain: result.chainKey };
         }
-        const chain2 = getChainById(chainKey);
-        if (!chain2 || chain2.namespace !== "eip155") {
+        const chain2 = requireChain(chainKey);
+        if (chain2.namespace !== "eip155") {
           throw new WalletError(
             "CHAIN_UNSUPPORTED",
             `transfer_token on ${chainKey} is not supported in WalletConnect mode (EVM-only). Switch to local wallet mode for ${chainKey} transfers.`
           );
         }
+        if (input2.tokenAddress) assertEvmAddress(input2.tokenAddress, "tokenAddress");
         const caipChainId = `${chain2.namespace}:${chain2.chainId}`;
+        const atomicAmount = parseAmount(input2.amount, decimals);
         let txHash;
-        if (contractAddress) {
-          const selector = "0xa9059cbb";
-          const paddedTo = input2.to.replace(/^0x/, "").toLowerCase().padStart(64, "0");
-          const paddedAmount = BigInt(input2.amount).toString(16).padStart(64, "0");
-          const data = selector + paddedTo + paddedAmount;
-          txHash = await wallet.sendTransaction({
-            chainId: caipChainId,
-            to: contractAddress,
-            data,
-            value: "0x0"
-          });
+        if (input2.tokenAddress) {
+          if (!this.blockchainClient) {
+            throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+          }
+          const pending = await this.blockchainClient.contract(erc20).withAddress(input2.tokenAddress, chainKey).write.transfer([input2.to, BigInt(atomicAmount)], wallet);
+          txHash = pending.txHash;
         } else {
-          const valueHex = "0x" + BigInt(input2.amount).toString(16);
+          assertEvmAddress(input2.to, "to");
+          const valueHex = "0x" + BigInt(atomicAmount).toString(16);
           txHash = await wallet.sendTransaction({
             chainId: caipChainId,
             to: input2.to,
@@ -44622,80 +45355,77 @@ var TokenActionProvider = class extends ActionProvider {
             value: valueHex
           });
         }
-        return { hash: txHash, chainKey };
+        return { hash: txHash, chain: chainKey };
       }
     };
   }
   approveToken() {
     return {
       name: "approve_token",
-      description: `Approve a spender to use tokens on your behalf (ERC-20 approve). SAFETY: when amount is "unlimited" (or the MaxUint256 decimal string), you MUST surface the risk to the user and get their explicit consent before calling this tool \u2014 unlimited approvals grant the spender access to ALL of the user's tokens of this type, including future transfers, and have been used in many drainer attacks. Prefer a finite amount equal to the immediate need. Use revoke_token_approval (or amount: "0") to revoke an existing approval.`,
+      description: `Approve a spender to use ERC-20 tokens on your behalf. SAFETY: when amount is "unlimited" (or the MaxUint256 decimal string), you MUST surface the risk to the user and get their explicit consent before calling this tool \u2014 unlimited approvals grant the spender access to ALL of the user's tokens of this type, including future transfers, and have been used in many drainer attacks. Prefer a finite amount equal to the immediate need. Use revoke_token_approval (or amount: "0") to revoke an existing approval.`,
       schema: import_zod10.z.object({
-        assetId: import_zod10.z.string().describe("Token ID to approve"),
+        chain: import_zod10.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod10.z.string().trim().min(1).describe("ERC-20 token contract address."),
         spender: import_zod10.z.string().describe("Spender address to approve"),
         amount: import_zod10.z.string().describe('Amount to approve (in smallest unit, or "unlimited")')
       }),
       invoke: async (_ctx, input2) => {
         const wallet = this.walletContext.activeWallet();
-        const { coinId, contractAddress } = parseTokenId(input2.assetId);
-        if (!contractAddress) {
-          throw new WalletError("VALIDATION_ERROR", "Cannot approve native token (no contract).");
-        }
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) {
-          throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported coin type: ${coinId}`);
-        }
-        const chain2 = getChainById(chainKey);
-        if (!chain2 || chain2.namespace !== "eip155") {
+        const chainKey = resolveChain(input2.chain);
+        const chain2 = requireChain(chainKey);
+        if (chain2.namespace !== "eip155") {
           throw new WalletError(
             "CHAIN_UNSUPPORTED",
             `approve_token on ${chainKey} is not supported \u2014 ERC-20 approvals are EVM-only.`
           );
         }
+        assertEvmAddress(input2.tokenAddress, "tokenAddress");
+        assertEvmAddress(input2.spender, "spender");
+        if (!this.blockchainClient) {
+          throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+        }
         const amount = input2.amount === "unlimited" ? "115792089237316195423570985008687907853269984665640564039457584007913129639935" : input2.amount;
-        const result = await wallet.approveErc20(chainKey, contractAddress, input2.spender, amount);
-        return { hash: result.txHash, chainKey };
+        const pending = await this.blockchainClient.contract(erc20).withAddress(input2.tokenAddress, chainKey).write.approve([input2.spender, BigInt(amount)], wallet);
+        return { hash: pending.txHash, chain: chainKey };
       }
     };
   }
   revokeTokenApproval() {
     return {
       name: "revoke_token_approval",
-      description: 'Revoke an ERC-20 token approval by setting the spender allowance to 0. Use this to remove a previously-granted allowance \u2014 especially important after unlimited approvals or any approval you no longer need. Applies only to ERC-20 tokens (asset IDs of form "c{coinId}_t{contract}"); native tokens have no approvals to revoke. This is the inverse of approve_token.',
+      description: "Revoke an ERC-20 token approval by setting the spender allowance to 0. Use this to remove a previously-granted allowance \u2014 especially important after unlimited approvals or any approval you no longer need. This is the inverse of approve_token.",
       schema: import_zod10.z.object({
-        assetId: import_zod10.z.string().describe(
-          'ERC-20 token ID to revoke approval for (e.g., "c60_t0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48" for USDC on Ethereum)'
-        ),
+        chain: import_zod10.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod10.z.string().trim().min(1).describe("ERC-20 token contract address whose allowance you want to revoke."),
         spender: import_zod10.z.string().describe("Spender address whose allowance should be set to 0")
       }),
       invoke: async (_ctx, input2) => {
         const wallet = this.walletContext.activeWallet();
-        const { coinId, contractAddress } = parseTokenId(input2.assetId);
-        if (!contractAddress) {
-          throw new WalletError("VALIDATION_ERROR", "Native tokens have no approval to revoke.");
-        }
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) {
-          throw new WalletError("CHAIN_UNSUPPORTED", `Unsupported coin type: ${coinId}`);
-        }
-        const chain2 = getChainById(chainKey);
-        if (!chain2 || chain2.namespace !== "eip155") {
+        const chainKey = resolveChain(input2.chain);
+        const chain2 = requireChain(chainKey);
+        if (chain2.namespace !== "eip155") {
           throw new WalletError(
             "CHAIN_UNSUPPORTED",
             `revoke_token_approval on ${chainKey} is not supported \u2014 ERC-20 approvals are EVM-only.`
           );
         }
-        const result = await wallet.approveErc20(chainKey, contractAddress, input2.spender, "0");
-        return { hash: result.txHash, chainKey };
+        assertEvmAddress(input2.tokenAddress, "tokenAddress");
+        assertEvmAddress(input2.spender, "spender");
+        if (!this.blockchainClient) {
+          throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
+        }
+        const pending = await this.blockchainClient.contract(erc20).withAddress(input2.tokenAddress, chainKey).write.approve([input2.spender, 0n], wallet);
+        return { hash: pending.txHash, chain: chainKey };
       }
     };
   }
   checkAllowance() {
     return {
       name: "check_allowance",
-      description: "Check the token allowance for a spender address",
+      description: "Check the ERC-20 allowance for a spender address.",
       schema: import_zod10.z.object({
-        assetId: import_zod10.z.string().describe("Token ID to check allowance for"),
+        chain: import_zod10.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod10.z.string().trim().min(1).describe("ERC-20 token contract address."),
         owner: import_zod10.z.string().describe("Token owner address"),
         spender: import_zod10.z.string().describe("Spender address to check")
       }),
@@ -44703,13 +45433,11 @@ var TokenActionProvider = class extends ActionProvider {
         if (!this.blockchainClient) {
           throw new WalletError("WALLET_NOT_FOUND", "BlockchainClient not available");
         }
-        const allowance = await this.blockchainClient.getAllowance({
-          assetId: input2.assetId,
-          owner: input2.owner,
-          spender: input2.spender
-        });
+        const chainKey = resolveChain(input2.chain);
+        const allowance = await this.blockchainClient.contract(erc20).withAddress(input2.tokenAddress, chainKey).read.allowance([input2.owner, input2.spender]);
         return {
-          assetId: input2.assetId,
+          chain: chainKey,
+          tokenAddress: input2.tokenAddress,
           owner: input2.owner,
           spender: input2.spender,
           allowance: allowance.toString()
@@ -44747,17 +45475,19 @@ var MarketActionProvider = class extends ActionProvider {
   checkTokenRisk() {
     return {
       name: "check_token_risk",
-      description: "Check security and risk information for a token (honeypot detection, audit status, freeze authority)",
+      description: "Check security and risk information for a token (honeypot detection, audit status, freeze authority). Omit `tokenAddress` to check the chain native coin.",
       schema: import_zod11.z.object({
-        assetId: import_zod11.z.string().describe("Asset ID (e.g., c60_t0xA0b8... for ERC-20, c60 for native)")
+        chain: import_zod11.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod11.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC)
       }),
       invoke: async (ctx, input2) => {
-        const status = await this.getService(ctx).checkCoinStatus(input2.assetId);
+        const { assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        const status = await this.getService(ctx).checkCoinStatus(assetId);
         const riskLevel = status.securityInfo?.riskLevel || status.solanaSecurityInfo?.riskLevel || "unknown";
         const isHoneypot = status.securityInfo?.isHoneypot ?? false;
         return {
           success: true,
-          assetId: input2.assetId,
+          assetId,
           name: status.name,
           symbol: status.symbol,
           isActive: status.isActive,
@@ -44773,32 +45503,58 @@ var MarketActionProvider = class extends ActionProvider {
     };
   }
 };
-var ERC20_TRANSFER_SIG2 = "0xa9059cbb";
-var EVM_ADDRESS_RE = /^0x[a-fA-F0-9]{40}$/;
 var DEFAULT_MAX_OFFRAMP_USD = 1e4;
-function encodeErc20Transfer2(to3, amount) {
-  const paddedTo = to3.slice(2).padStart(64, "0");
-  const paddedAmount = amount.toString(16).padStart(64, "0");
-  return `${ERC20_TRANSFER_SIG2}${paddedTo}${paddedAmount}`;
+function validateOfframpInput(input2, chainKey, nativeDecimals) {
+  if (!isEvmAddress(input2.depositAddress)) {
+    throw new TransferError(
+      "VALIDATION_ERROR",
+      `depositAddress is not a valid EVM address: ${input2.depositAddress}. Double-check what the provider displayed.`
+    );
+  }
+  if (input2.tokenAddress && !isEvmAddress(input2.tokenAddress)) {
+    throw new TransferError("VALIDATION_ERROR", `Malformed tokenAddress: ${input2.tokenAddress}`);
+  }
+  let decimals;
+  if (input2.tokenAddress) {
+    if (input2.decimals === void 0) {
+      throw new TransferError(
+        "VALIDATION_ERROR",
+        `decimals is required for ERC-20 token ${input2.tokenAddress} on ${chainKey}. Pass the token's decimals explicitly (6 for USDC/USDT, 18 for DAI, etc.) \u2014 silently defaulting to 18 could over-pay the provider by orders of magnitude.`
+      );
+    }
+    decimals = input2.decimals;
+  } else {
+    decimals = nativeDecimals;
+  }
+  try {
+    assertStrictPositiveAmount(input2.cryptoAmount, decimals);
+  } catch (err) {
+    throw new TransferError("VALIDATION_ERROR", err instanceof Error ? err.message : String(err));
+  }
+  return decimals;
 }
-function buildFollowUp(cryptoAsset, address, direction, paymentMethod) {
-  if (!cryptoAsset) return void 0;
-  let parsed;
+async function checkOfframpUsdCap(priceLookup, maxUsd, chainKey, tokenAddress, cryptoAmount) {
   try {
-    parsed = parseTokenId(cryptoAsset);
+    const tokenInfo = tokenAddress ? resolveToken(tokenAddress, chainKey) : void 0;
+    const lookupAddress2 = tokenInfo?.address ?? tokenAddress ?? "";
+    const price = await priceLookup.getTokenPrice(chainKey, lookupAddress2);
+    if (price && price > 0) {
+      const usdValue = parseFloat(cryptoAmount) * price;
+      if (usdValue > maxUsd) {
+        return {
+          code: "USD_LIMIT_EXCEEDED",
+          message: `Off-ramp payout value ~$${usdValue.toFixed(2)} USD exceeds safety limit of $${maxUsd}. Use the CLI with --max-usd ${Math.ceil(usdValue)} or --skip-safety-check to proceed.`
+        };
+      }
+    }
   } catch {
-    return void 0;
-  }
-  const isErc20 = Boolean(parsed.contractAddress);
-  const action = isErc20 ? "get_token_holdings" : "get_balance";
-  let args;
-  if (action === "get_balance") {
-    const chainKey = coinTypeToChainKey(parsed.coinId);
-    if (!chainKey) return void 0;
-    args = parsed.contractAddress ? { address, chainKey, tokenAddress: parsed.contractAddress } : { address, chainKey };
-  } else {
-    args = { address, coin: parsed.coinId };
   }
+  return void 0;
+}
+function buildFollowUp(chain2, tokenAddress, address, direction, paymentMethod) {
+  if (!chain2) return void 0;
+  const action = tokenAddress ? "get_token_holdings" : "get_balance";
+  const args = tokenAddress ? { address, chain: chain2, tokenAddress } : { address, chain: chain2 };
   if (direction === "onramp") {
     return {
       action,
@@ -44855,11 +45611,15 @@ var OnrampActionProvider = class extends ActionProvider {
   // TransferActionProvider for the off-ramp payout path (confirm_offramp_transfer).
   // Off-ramp sends crypto to a third-party deposit address, so the cap is
   // strictly more important here than for peer-to-peer transfers.
-  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_OFFRAMP_USD) {
+  // `blockchainClient` is the 4th (optional) arg, not the 1st — see
+  // TransferActionProvider for the rationale (avoid churning ~70 test sites).
+  // Normalize across action providers in a follow-up.
+  constructor(walletContext, priceLookup, maxTransferUsd = DEFAULT_MAX_OFFRAMP_USD, blockchainClient) {
     super();
     this.walletContext = walletContext;
     this.priceLookup = priceLookup;
     this.maxTransferUsd = maxTransferUsd;
+    this.blockchainClient = blockchainClient;
   }
   name = "onramp";
   description = "Fiat on-ramp and off-ramp \u2014 buy crypto with fiat (USD, EUR, etc.) or sell crypto for fiat payouts. On-ramp: two-step flow (get quote \u2192 get checkout URL), provider sends crypto to the destination address. Off-ramp: three-step flow (get quote \u2192 get checkout URL \u2192 confirm_offramp_transfer). The off-ramp checkout URL runs in a plain browser which has no access to wallet keys, so the payout transaction must be broadcast natively via confirm_offramp_transfer once the user has read the provider's deposit address and exact amount. Destination/source address auto-derives from the configured wallet using the asset's chain. IMPORTANT: TWAK has no background polling or completion webhook for ramps. Tool responses include a `followUp` hint telling the agent exactly which balance tool to poll (with args and timing) to observe completion.";
@@ -44872,19 +45632,12 @@ var OnrampActionProvider = class extends ActionProvider {
       this.confirmOfframpTransfer()
     ];
   }
-  async resolveAddress(providedAddress, cryptoAsset) {
+  async resolveAddress(providedAddress, chainKey) {
     if (providedAddress) return providedAddress;
-    if (!cryptoAsset) {
-      throw new TransferError(
-        "VALIDATION_ERROR",
-        "walletAddress not provided and cryptoAsset is missing \u2014 cannot derive chain. Pass walletAddress or cryptoAsset."
-      );
-    }
-    const chainKey = tokenIdToChain(cryptoAsset);
     if (!chainKey) {
       throw new TransferError(
-        "CHAIN_UNSUPPORTED",
-        `Cannot determine chain for asset ${cryptoAsset}. Pass walletAddress explicitly.`
+        "VALIDATION_ERROR",
+        "walletAddress not provided and chain is missing \u2014 cannot derive address. Pass walletAddress or chain."
       );
     }
     return this.walletContext.activeWallet().getAddress(chainKey);
@@ -44896,15 +45649,15 @@ var OnrampActionProvider = class extends ActionProvider {
       schema: import_zod12.z.object({
         fiatAmount: import_zod12.z.coerce.number().positive().describe("Amount of fiat currency to spend (e.g., 100 for $100)."),
         fiatCurrency: import_zod12.z.string().length(3).default("USD").describe("Fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
-        cryptoAsset: import_zod12.z.string().describe(
-          "Target crypto asset ID. Format: c<coinId> for native coins (e.g., c60 for ETH, c0 for BTC, c501 for SOL) or c<coinId>_t<contract> for tokens (e.g., c60_t0xA0b8... for USDC on Ethereum)."
-        ),
+        chain: import_zod12.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod12.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         walletAddress: import_zod12.z.string().optional().describe(
-          "Destination wallet address where the purchased crypto will be sent. OMIT to auto-derive from the configured wallet using cryptoAsset's chain \u2014 this is the safe default and prevents sending funds to a stranger by mistake. Only supply this when operating on behalf of a different user."
+          "Destination wallet address where the purchased crypto will be sent. OMIT to auto-derive from the configured wallet using the chain \u2014 this is the safe default and prevents sending funds to a stranger by mistake. Only supply this when operating on behalf of a different user."
         )
       }),
       invoke: async (ctx, input2) => {
-        const address = await this.resolveAddress(input2.walletAddress, input2.cryptoAsset);
+        const { chainKey, assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        const address = await this.resolveAddress(input2.walletAddress, chainKey);
         const query = new URLSearchParams({
           amount: input2.fiatAmount.toString(),
           currency: input2.fiatCurrency,
@@ -44912,7 +45665,7 @@ var OnrampActionProvider = class extends ActionProvider {
         });
         const result = await ctx.httpClient.gateway(
           "GET",
-          `/v1/buycrypto/quote/${encodeURIComponent(input2.cryptoAsset)}`,
+          `/v1/buycrypto/quote/${encodeURIComponent(assetId)}`,
           void 0,
           query.toString()
         );
@@ -44922,9 +45675,10 @@ var OnrampActionProvider = class extends ActionProvider {
           success: true,
           summary: summarizeOnrampQuotes(quotes),
           address,
-          cryptoAsset: input2.cryptoAsset,
+          chain: chainKey,
+          tokenAddress: input2.tokenAddress,
           quotes,
-          nextAction: quotes.length > 0 ? "Call get_onramp_url with the chosen quoteId to receive a browser redirect URL for checkout. quotes[0] is the best deal (lowest vsBestPct)." : "No quotes available \u2014 try a different fiatAmount or cryptoAsset."
+          nextAction: quotes.length > 0 ? "Call get_onramp_url with the chosen quoteId to receive a browser redirect URL for checkout. quotes[0] is the best deal (lowest vsBestPct)." : "No quotes available \u2014 try a different fiatAmount or chain/tokenAddress."
         };
       }
     };
@@ -44936,14 +45690,16 @@ var OnrampActionProvider = class extends ActionProvider {
       schema: import_zod12.z.object({
         quoteId: import_zod12.z.string().describe("Quote ID returned by get_onramp_quote."),
         walletAddress: import_zod12.z.string().optional().describe(
-          "Destination wallet address. OMIT to auto-derive from the configured wallet \u2014 requires cryptoAsset so the chain can be determined. Only supply this when operating on behalf of a different user."
+          "Destination wallet address. OMIT to auto-derive from the configured wallet \u2014 requires chain so the address can be derived. Only supply this when operating on behalf of a different user."
         ),
-        cryptoAsset: import_zod12.z.string().optional().describe(
-          "Crypto asset ID that was used for the quote (e.g., c60 for ETH). Required when walletAddress is omitted so the chain can be derived for address lookup."
-        )
+        chain: import_zod12.z.string().optional().describe(
+          `${CHAIN_DESC} Required when walletAddress is omitted so the address can be derived.`
+        ),
+        tokenAddress: import_zod12.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC)
       }),
       invoke: async (ctx, input2) => {
-        const address = await this.resolveAddress(input2.walletAddress, input2.cryptoAsset);
+        const chainKey = input2.chain !== void 0 ? resolveAsset(input2.chain).chainKey : void 0;
+        const address = await this.resolveAddress(input2.walletAddress, chainKey);
         const query = new URLSearchParams({ address });
         let result;
         try {
@@ -44966,7 +45722,7 @@ var OnrampActionProvider = class extends ActionProvider {
           throw err;
         }
         const url = result.url ?? result.redirect_url;
-        const followUp = url ? buildFollowUp(input2.cryptoAsset, address, "onramp") : void 0;
+        const followUp = url ? buildFollowUp(chainKey, input2.tokenAddress, address, "onramp") : void 0;
         return {
           success: Boolean(url),
           address,
@@ -44983,24 +45739,24 @@ var OnrampActionProvider = class extends ActionProvider {
       description: "Step 1 of selling crypto for fiat: get quotes from available providers for converting a crypto amount into fiat. Returns an array of quotes each with a quoteId \u2014 pass one to get_offramp_url to generate the checkout redirect for completing KYC and order creation. The provider page cannot sign the payout (no key access in the browser); the agent must broadcast it natively via confirm_offramp_transfer once the deposit address is known.",
       schema: import_zod12.z.object({
         cryptoAmount: import_zod12.z.coerce.number().positive().describe("Amount of crypto to sell (e.g., 0.1 for 0.1 ETH)."),
-        cryptoAsset: import_zod12.z.string().describe(
-          "Crypto asset ID to sell. Format: c<coinId> for native coins (e.g., c60 for ETH, c0 for BTC) or c<coinId>_t<contract> for tokens."
-        ),
+        chain: import_zod12.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod12.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC),
         fiatCurrency: import_zod12.z.string().length(3).default("USD").describe("Target fiat currency as a 3-letter ISO 4217 code (e.g., USD, EUR, GBP)."),
         paymentMethod: import_zod12.z.enum(["ANY", "bank_transfer", "card"]).optional().default("ANY").describe(
           'Payout method. Default "ANY" is a sentinel that matches any provider \u2014 recommended unless you specifically need "card" or "bank_transfer". Sending an unrecognised value (or `bank_transfer` in regions without bank-payout coverage) silently returns an empty quotes array.'
         ),
         walletAddress: import_zod12.z.string().optional().describe(
-          "Source wallet address holding the crypto to be sold. OMIT to auto-derive from the configured wallet using cryptoAsset's chain \u2014 this is the safe default. Only supply this when operating on behalf of a different user."
+          "Source wallet address holding the crypto to be sold. OMIT to auto-derive from the configured wallet using the chain \u2014 this is the safe default. Only supply this when operating on behalf of a different user."
         )
       }),
       invoke: async (ctx, input2) => {
-        const address = await this.resolveAddress(input2.walletAddress, input2.cryptoAsset);
+        const { chainKey, assetId } = resolveAsset(input2.chain, input2.tokenAddress);
+        const address = await this.resolveAddress(input2.walletAddress, chainKey);
         const query = new URLSearchParams({
           amount: input2.cryptoAmount.toString(),
           currency: input2.fiatCurrency,
           // iOS sends `asset_id` as both path segment AND query param. Mirroring that.
-          asset_id: input2.cryptoAsset,
+          asset_id: assetId,
           address,
           // The HTTP gateway uses `payment_method` for both buy and sell, mirroring the
           // iOS production client. The sell proto declares `payout_method` but the
@@ -45012,7 +45768,7 @@ var OnrampActionProvider = class extends ActionProvider {
         });
         const result = await ctx.httpClient.gateway(
           "GET",
-          `/v1/sellcrypto/quote/${encodeURIComponent(input2.cryptoAsset)}`,
+          `/v1/sellcrypto/quote/${encodeURIComponent(assetId)}`,
           void 0,
           query.toString()
         );
@@ -45022,9 +45778,10 @@ var OnrampActionProvider = class extends ActionProvider {
           success: true,
           summary: summarizeOfframpQuotes(quotes),
           address,
-          cryptoAsset: input2.cryptoAsset,
+          chain: chainKey,
+          tokenAddress: input2.tokenAddress,
           quotes,
-          nextAction: quotes.length > 0 ? "Call get_offramp_url with the chosen quoteId to receive a browser redirect URL for the sale. quotes[0] is the best deal (lowest vsBestPct)." : "No quotes available \u2014 try a different cryptoAmount, cryptoAsset, or paymentMethod."
+          nextAction: quotes.length > 0 ? "Call get_offramp_url with the chosen quoteId to receive a browser redirect URL for the sale. quotes[0] is the best deal (lowest vsBestPct)." : "No quotes available \u2014 try a different cryptoAmount, chain/tokenAddress, or paymentMethod."
         };
       }
     };
@@ -45036,14 +45793,16 @@ var OnrampActionProvider = class extends ActionProvider {
       schema: import_zod12.z.object({
         quoteId: import_zod12.z.string().describe("Quote ID returned by get_offramp_quote."),
         walletAddress: import_zod12.z.string().optional().describe(
-          "Source wallet address. OMIT to auto-derive from the configured wallet \u2014 requires cryptoAsset so the chain can be determined. Only supply this when operating on behalf of a different user."
+          "Source wallet address. OMIT to auto-derive from the configured wallet \u2014 requires chain so the address can be derived. Only supply this when operating on behalf of a different user."
         ),
-        cryptoAsset: import_zod12.z.string().optional().describe(
-          "Crypto asset ID that was used for the quote (e.g., c60 for ETH). Required when walletAddress is omitted so the chain can be derived for address lookup."
-        )
+        chain: import_zod12.z.string().optional().describe(
+          `${CHAIN_DESC} Required when walletAddress is omitted so the address can be derived.`
+        ),
+        tokenAddress: import_zod12.z.string().trim().min(1).optional().describe(TOKEN_ADDR_DESC)
       }),
       invoke: async (ctx, input2) => {
-        const address = await this.resolveAddress(input2.walletAddress, input2.cryptoAsset);
+        const chainKey = input2.chain !== void 0 ? resolveAsset(input2.chain).chainKey : void 0;
+        const address = await this.resolveAddress(input2.walletAddress, chainKey);
         const query = new URLSearchParams({ address });
         let result;
         try {
@@ -45066,7 +45825,7 @@ var OnrampActionProvider = class extends ActionProvider {
           throw err;
         }
         const url = result.url ?? result.redirect_url;
-        const followUp = url ? buildFollowUp(input2.cryptoAsset, address, "offramp") : void 0;
+        const followUp = url ? buildFollowUp(chainKey, input2.tokenAddress, address, "offramp") : void 0;
         return {
           success: Boolean(url),
           address,
@@ -45081,7 +45840,7 @@ var OnrampActionProvider = class extends ActionProvider {
   confirmOfframpTransfer() {
     return {
       name: "confirm_offramp_transfer",
-      description: "Step 3 of selling crypto for fiat: sign and broadcast the payout transaction to the provider's deposit address. Call this AFTER the user has completed KYC in the browser and can read the deposit address + exact amount the provider displayed. Works with any wallet provider that implements sendTransaction (the local agent wallet, or a WalletConnect-paired external wallet). EVM-only \u2014 for BTC / Solana / Cosmos off-ramps use the `twak onramp sell-confirm` CLI command instead. Returns a tx hash on success; fiat payout from the provider then arrives separately (no on-chain signal for that step).",
+      description: "Step 3 of selling crypto for fiat: sign and broadcast the payout transaction to the provider's deposit address. Call this AFTER the user has completed KYC in the browser and can read the deposit address + exact amount the provider displayed. Works with any wallet provider that implements sendTransaction (the local agent wallet, or a WalletConnect-paired external wallet). EVM-only \u2014 non-EVM chains (BTC, Solana, Cosmos, etc.) are not supported by this action. Returns a tx hash on success; fiat payout from the provider then arrives separately (no on-chain signal for that step).",
       schema: import_zod12.z.object({
         depositAddress: import_zod12.z.string().describe(
           "The deposit address displayed by the provider after KYC. This is a third-party address \u2014 verify it matches what the provider shows before calling."
@@ -45089,8 +45848,9 @@ var OnrampActionProvider = class extends ActionProvider {
         cryptoAmount: import_zod12.z.string().describe(
           'Exact amount to send in human-readable format (e.g., "0.1" for 0.1 ETH). Must match the amount the provider displays; under-sending will invalidate the sell order.'
         ),
-        cryptoAsset: import_zod12.z.string().describe(
-          "Crypto asset being sold. Format: c<coinId> for native coins (e.g., c60 for ETH) or c<coinId>_t<contract> for ERC-20 tokens."
+        chain: import_zod12.z.string().describe(CHAIN_DESC),
+        tokenAddress: import_zod12.z.string().trim().min(1).optional().describe(
+          "ERC-20 token contract address. Omit for the chain native coin. This action is EVM-only \u2014 non-EVM tokens are rejected."
         ),
         decimals: import_zod12.z.coerce.number().optional().describe(
           "Token decimals. REQUIRED for ERC-20 assets (pass 6 for USDC/USDT, 18 for DAI, etc.) \u2014 omitting it will be rejected rather than silently defaulting to 18, because a wrong-decimals encode can over-pay the provider by orders of magnitude. Ignored for native coins."
@@ -45104,82 +45864,37 @@ var OnrampActionProvider = class extends ActionProvider {
       }),
       invoke: async (_ctx, input2) => {
         const signer = this.walletContext.activeWallet();
-        let parsed;
-        try {
-          parsed = parseTokenId(input2.cryptoAsset);
-        } catch {
-          throw new TransferError("VALIDATION_ERROR", `Invalid cryptoAsset: ${input2.cryptoAsset}`);
-        }
-        const chainKey = coinTypeToChainKey(parsed.coinId);
-        if (!chainKey) {
+        const { chainKey } = resolveAsset(input2.chain);
+        const chainDef = requireChain(chainKey);
+        if (chainDef.namespace !== "eip155") {
           throw new TransferError(
             "CHAIN_UNSUPPORTED",
-            `Unsupported coin type in cryptoAsset: ${input2.cryptoAsset}`
-          );
-        }
-        const chainDef = getChainById(chainKey);
-        if (!chainDef || chainDef.namespace !== "eip155") {
-          throw new TransferError(
-            "CHAIN_UNSUPPORTED",
-            `confirm_offramp_transfer is EVM-only. For ${chainKey} off-ramps use the CLI: twak onramp sell-confirm --asset ${input2.cryptoAsset} --to <deposit> --amount <n>${input2.memo ? " --memo <tag>" : ""}.`
+            `confirm_offramp_transfer is EVM-only. ${chainKey} is not supported.`
           );
         }
         const caip2 = `eip155:${chainDef.chainId}`;
-        if (!EVM_ADDRESS_RE.test(input2.depositAddress)) {
-          throw new TransferError(
-            "VALIDATION_ERROR",
-            `depositAddress is not a valid EVM address: ${input2.depositAddress}. Double-check what the provider displayed.`
-          );
-        }
-        if (parsed.contractAddress && !EVM_ADDRESS_RE.test(parsed.contractAddress)) {
-          throw new TransferError(
-            "VALIDATION_ERROR",
-            `Malformed token contract in cryptoAsset: ${parsed.contractAddress}`
-          );
-        }
-        if (parsed.contractAddress && input2.decimals === void 0) {
-          throw new TransferError(
-            "VALIDATION_ERROR",
-            `decimals is required for ERC-20 asset ${input2.cryptoAsset}. Pass the token's decimals explicitly (6 for USDC/USDT, 18 for DAI, etc.) \u2014 silently defaulting to 18 could over-pay the provider by orders of magnitude.`
-          );
-        }
-        const decimals = parsed.contractAddress ? input2.decimals : 18;
-        try {
-          assertStrictPositiveAmount(input2.cryptoAmount, decimals);
-        } catch (err) {
-          throw new TransferError(
-            "VALIDATION_ERROR",
-            err instanceof Error ? err.message : String(err)
-          );
-        }
+        const decimals = validateOfframpInput(input2, chainKey, chainDef.decimals);
         if (this.priceLookup) {
-          try {
-            const tokenInfo = resolveToken(input2.cryptoAsset, chainKey);
-            const tokenAddress = tokenInfo?.address ?? parsed.contractAddress ?? "";
-            const price = await this.priceLookup.getTokenPrice(chainKey, tokenAddress);
-            if (price && price > 0) {
-              const usdValue = parseFloat(input2.cryptoAmount) * price;
-              if (usdValue > this.maxTransferUsd) {
-                return {
-                  success: false,
-                  code: "USD_LIMIT_EXCEEDED",
-                  message: `Off-ramp payout value ~$${usdValue.toFixed(2)} USD exceeds safety limit of $${this.maxTransferUsd}. Use the CLI with --max-usd ${Math.ceil(usdValue)} or --skip-safety-check to proceed.`
-                };
-              }
-            }
-          } catch {
-          }
+          const cap = await checkOfframpUsdCap(
+            this.priceLookup,
+            this.maxTransferUsd,
+            chainKey,
+            input2.tokenAddress,
+            input2.cryptoAmount
+          );
+          if (cap) return { success: false, ...cap };
         }
         const atomic = parseAmount(input2.cryptoAmount, decimals);
         let txHash;
-        if (parsed.contractAddress) {
-          const calldata = encodeErc20Transfer2(input2.depositAddress, BigInt(atomic));
-          txHash = await signer.sendTransaction({
-            chainId: caip2,
-            to: parsed.contractAddress,
-            data: calldata,
-            value: "0x0"
-          });
+        if (input2.tokenAddress) {
+          if (!this.blockchainClient) {
+            throw new TransferError(
+              "WALLET_NOT_FOUND",
+              "BlockchainClient not available \u2014 off-ramp token payout requires a configured blockchain client"
+            );
+          }
+          const pending = await this.blockchainClient.contract(erc20).withAddress(input2.tokenAddress, chainKey).write.transfer([input2.depositAddress, BigInt(atomic)], signer);
+          txHash = pending.txHash;
         } else {
           txHash = await signer.sendTransaction({
             chainId: caip2,
@@ -45193,13 +45908,13 @@ var OnrampActionProvider = class extends ActionProvider {
           success: true,
           txHash,
           chain: chainKey,
+          tokenAddress: input2.tokenAddress,
           to: input2.depositAddress,
           amount: input2.cryptoAmount,
-          asset: input2.cryptoAsset,
           memoIgnored: input2.memo ? `A memo was supplied (${input2.memo}) but EVM transactions have no memo field \u2014 it was ignored. If the provider requires a memo, they likely expect a non-EVM chain.` : void 0,
           quoteId: input2.quoteId,
           explorer: explorerUrl,
-          summary: `Off-ramp payout of ${input2.cryptoAmount} ${input2.cryptoAsset} broadcast to ${input2.depositAddress} on ${chainKey}. Fiat payout from the provider arrives separately.`
+          summary: `Off-ramp payout of ${input2.cryptoAmount}${input2.tokenAddress ? ` ${input2.tokenAddress.slice(0, 10)}\u2026` : ` ${chainDef.symbol}`} broadcast to ${input2.depositAddress} on ${chainKey}. Fiat payout from the provider arrives separately.`
         };
       }
     };
@@ -45231,7 +45946,7 @@ var AutomateActionProvider = class extends ActionProvider {
         type: import_zod13.z.enum(["dca", "limit"]).describe("Automation type: dca (recurring) or limit (price trigger)"),
         fromToken: import_zod13.z.string().describe("Source token symbol or address"),
         toToken: import_zod13.z.string().describe("Destination token symbol or address"),
-        chain: import_zod13.z.string().default("ethereum").describe("Chain name"),
+        chain: import_zod13.z.string().default("ethereum").describe(CHAIN_DESC),
         amount: import_zod13.z.string().describe("Amount of fromToken per execution"),
         intervalMs: import_zod13.z.coerce.number().optional().describe("Interval in milliseconds for DCA (e.g., 86400000 for daily)"),
         targetPrice: import_zod13.z.coerce.number().optional().describe("Target price in USD for limit orders"),
@@ -45252,11 +45967,12 @@ var AutomateActionProvider = class extends ActionProvider {
             message: "Limit orders require targetPrice and condition"
           };
         }
+        const chainKey = resolveChain(input2.chain);
         const record2 = await this.automationStore.create({
           type: input2.type,
           fromToken: input2.fromToken,
           toToken: input2.toToken,
-          chain: input2.chain,
+          chain: chainKey,
           amount: input2.amount,
           intervalMs: input2.intervalMs,
           targetPrice: input2.targetPrice,
@@ -45432,7 +46148,7 @@ var X402ActionProvider = class extends ActionProvider {
   x402Quote() {
     return {
       name: "x402_quote",
-      description: 'Preview the payment requirements at an x402 payment-gated endpoint WITHOUT signing or paying. Returns the full list of payment options (each entry has chain, asset address, tokenName, amount, transferMethod, requiresApproval, and a pre-formatted `description` string). CRITICAL \u2014 after this returns, ALWAYS surface ALL entries in `accepts[]` to the user (as a short numbered list: chain \xB7 token \xB7 amount \xB7 method \xB7 "preferred" tag if applicable) and ask which to use BEFORE calling x402_request. Do not silently pick the `preferred` entry just because it is marked preferred \u2014 that is the picker default if no override is passed, but the user deserves to see every option (other chains may have cheaper gas, the user may hold balance only on a specific chain, etc.). The only exception: if you have already done a balance check and only one entry is viable, you may proceed with that one after noting the others as "unavailable (no balance)". IMPORTANT: each entry in `accepts[]` is an INDEPENDENT payment option \u2014 a unique (chain, token, transfer method) triple. Do NOT merge entries by chain (e.g. "BSC USDC via EIP-3009 or Permit2" is wrong if BSC USDC is only offered via Permit2 and a separate BSC entry for a different token offers EIP-3009). Read each entry as its own row; use the per-entry `description` field verbatim when surfacing options to the user. Once the user picks, call x402_request with the agreed maxPaymentAtomic plus optionally preferNetwork/preferMethod/preferAsset to disambiguate. INTERPRETING `requiresApproval`: `false` (EIP-3009, e.g. USDC on Base / Ethereum) \u2014 gasless. Sign the payment and you are done. No setup, no on-chain tx for the buyer, ever. `true` (Permit2, e.g. USDC on BSC) \u2014 the industry-standard Permit2 flow used by Uniswap, 1inch, and most major DeFi apps. THE FIRST x402_request to a Permit2 endpoint for a given token+chain broadcasts a one-time `approve(Permit2, MAX_UINT256)` tx (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet). The allowance granted is unlimited for the canonical Permit2 contract at 0x000000000022D473030F116dDEE9F6B43aC78BA3. After that, every future Permit2 payment for that token is signature-only (gasless). Revocable any time via `twak erc20 revoke`. The per-call spend is still capped at the request `maxPaymentAtomic` \u2014 unlimited allowance does NOT mean unlimited per-call spend. When `requiresApproval: true` AND the buyer has not used Permit2 for that token on that chain before, the agent SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) before calling x402_request. BALANCE CHECK \u2014 AFTER this quote returns and BEFORE recommending any route or showing the menu to the user, check the wallet balance for every viable entry in `accepts`. For each entry: call `get_address(chainKey)` to find the wallet address on that chain, then `get_balance` for the entry\'s asset (or `wallet_balance(chainKey)` for native coins). Filter or annotate the menu \u2014 only recommend routes where the wallet has enough of the asset to cover `amount`. If a Permit2 entry needs a first-time approval (`requiresApproval: true`), also confirm the wallet holds some native chain gas (gas amount varies by chain). If no viable route has sufficient balance, tell the user upfront \u2014 do not present a menu that includes routes they cannot pay. This avoids the failure mode where the agent recommends a chain the user has no balance on and the user finds out only after committing. No wallet required \u2014 read-only HTTPS + 402 parse. HTTPS-only; private IPs and non-HTTPS schemes are rejected.',
+      description: 'Preview the payment requirements at an x402 payment-gated endpoint WITHOUT signing or paying. Returns the full list of payment options (each entry has chain, asset address, tokenName, amount, transferMethod, requiresApproval, and a pre-formatted `description` string). CRITICAL \u2014 after this returns, ALWAYS surface ALL entries in `accepts[]` to the user (as a short numbered list: chain \xB7 token \xB7 amount \xB7 method \xB7 "preferred" tag if applicable) and ask which to use BEFORE calling x402_request. Do not silently pick the `preferred` entry just because it is marked preferred \u2014 that is the picker default if no override is passed, but the user deserves to see every option (other chains may have cheaper gas, the user may hold balance only on a specific chain, etc.). The only exception: if you have already done a balance check and only one entry is viable, you may proceed with that one after noting the others as "unavailable (no balance)". IMPORTANT: each entry in `accepts[]` is an INDEPENDENT payment option \u2014 a unique (chain, token, transfer method) triple. Do NOT merge entries by chain (e.g. "BSC USDC via EIP-3009 or Permit2" is wrong if BSC USDC is only offered via Permit2 and a separate BSC entry for a different token offers EIP-3009). Read each entry as its own row; use the per-entry `description` field verbatim when surfacing options to the user. Once the user picks, call x402_request with the agreed maxPaymentAtomic plus optionally preferNetwork/preferMethod/preferAsset to disambiguate. INTERPRETING `requiresApproval`: `false` (EIP-3009, e.g. USDC on Base / Ethereum) \u2014 gasless. Sign the payment and you are done. No setup, no on-chain tx for the buyer, ever. `true` (Permit2, e.g. USDC on BSC) \u2014 the industry-standard Permit2 flow used by Uniswap, 1inch, and most major DeFi apps. THE FIRST x402_request to a Permit2 endpoint for a given token+chain broadcasts a one-time `approve(Permit2, MAX_UINT256)` tx (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet). The allowance granted is unlimited for the canonical Permit2 contract at 0x000000000022D473030F116dDEE9F6B43aC78BA3. After that, every future Permit2 payment for that token is signature-only (gasless). Revocable any time via `twak erc20 revoke`. The per-call spend is still capped at the request `maxPaymentAtomic` \u2014 unlimited allowance does NOT mean unlimited per-call spend. When `requiresApproval: true` AND the buyer has not used Permit2 for that token on that chain before, the agent SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) before calling x402_request. BALANCE CHECK \u2014 AFTER this quote returns and BEFORE recommending any route or showing the menu to the user, check the wallet balance for every viable entry in `accepts`. For each entry: call `get_address(chain)` to find the wallet address on that chain, then `get_balance` for the entry\'s asset (or `wallet_balance(chain)` for native coins). Filter or annotate the menu \u2014 only recommend routes where the wallet has enough of the asset to cover `amount`. If a Permit2 entry needs a first-time approval (`requiresApproval: true`), also confirm the wallet holds some native chain gas (gas amount varies by chain). If no viable route has sufficient balance, tell the user upfront \u2014 do not present a menu that includes routes they cannot pay. This avoids the failure mode where the agent recommends a chain the user has no balance on and the user finds out only after committing. No wallet required \u2014 read-only HTTPS + 402 parse. HTTPS-only; private IPs and non-HTTPS schemes are rejected.',
       schema: import_zod14.z.object({
         url: import_zod14.z.string().describe(
           "Target endpoint URL. Must be HTTPS. Resolves via DNS; private/local IPs are rejected."
@@ -45448,7 +46164,7 @@ var X402ActionProvider = class extends ActionProvider {
   x402Request() {
     return {
       name: "x402_request",
-      description: "Make an HTTP request to an x402 payment-gated endpoint. Handles the full flow: sends the initial request, parses any 402 challenge, signs an EIP-3009 or Permit2 payment authorization with the agent wallet, retries with the X-Payment header. PAYMENT METHODS: x402 endpoints offer one or more options in their 402 response. EIP-3009 is gasless for the buyer (no setup, no approval) \u2014 preferred when available, e.g. USDC on Base / Ethereum. Permit2 needs a one-time approve(Permit2, MAX) tx on the chain (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet), then every future Permit2 payment for that token is signature-only. Permit2 is required when the token does not support EIP-3009 \u2014 e.g. USDC on BSC. SAFETY \u2014 autoApprove decision: When autoApprove=true (default), this action silently broadcasts the one-time Permit2 approval if your wallet has not yet approved the canonical Permit2 contract for that token. The approval is to the same Permit2 contract Uniswap, 1inch, and most major DeFi apps use \u2014 it is not exotic infrastructure. The approval alone does not move funds; each subsequent payment still needs a fresh signature. Revocable any time via `twak erc20 revoke`. For first-time use of an endpoint you SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) and get their go-ahead before calling. After the approval lands, subsequent Permit2 payments for that token are free of further approvals. Set autoApprove=false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead of broadcasting \u2014 useful when the user is not around or you want to handle the approval out-of-band. maxPaymentAtomic is the user's pre-commitment to a maximum payment in the asset's smallest unit (e.g. \"10000\" = 0.01 USDC at 6 decimals). If the server demands more than this cap, the call returns code: 'PAYMENT_AMOUNT_EXCEEDED' \u2014 DO NOT retry with a higher cap without asking the user. BALANCE CHECK \u2014 Before calling this action, verify the wallet holds enough of the chosen asset on the chosen chain. Call `get_address(chainKey)` to find the wallet address, then `get_balance` for the asset (or `wallet_balance(chainKey)` for native coins). For Permit2 first-time use, also confirm the wallet holds some native chain gas (amount varies by chain). Surface insufficient balance to the user BEFORE calling this action \u2014 a failed payment mid-flow can leave the wallet in a half-state (e.g. Permit2 approval broadcast, then the transfer signature fails). The balance check should already have happened during the `x402_quote` flow that produced the menu; redo it here only if you skipped quote or the balance might have changed since. WALLET \u2014 Signs through whichever wallet mode is active for this session (local by default; switchable via `switch_wallet_mode`). If mode='local', signs in-process (no external prompt). If mode='walletconnect', signs over the WalletConnect relay \u2014 the user must approve each signature on their paired wallet. To retrieve the active wallet's address for a chain (e.g. to call `wallet_balance` / `get_balance`), call `get_address` with the chain key (e.g. \"bsc\", \"base\"), or `list_addresses` for all chains at once. HTTPS-only; non-HTTPS schemes and private IPs are rejected before any payment signing.",
+      description: "Make an HTTP request to an x402 payment-gated endpoint. Handles the full flow: sends the initial request, parses any 402 challenge, signs an EIP-3009 or Permit2 payment authorization with the agent wallet, retries with the X-Payment header. PAYMENT METHODS: x402 endpoints offer one or more options in their 402 response. EIP-3009 is gasless for the buyer (no setup, no approval) \u2014 preferred when available, e.g. USDC on Base / Ethereum. Permit2 needs a one-time approve(Permit2, MAX) tx on the chain (the buyer pays the gas \u2014 usually a few cents on BSC / Base, more on Ethereum mainnet), then every future Permit2 payment for that token is signature-only. Permit2 is required when the token does not support EIP-3009 \u2014 e.g. USDC on BSC. SAFETY \u2014 autoApprove decision: When autoApprove=true (default), this action silently broadcasts the one-time Permit2 approval if your wallet has not yet approved the canonical Permit2 contract for that token. The approval is to the same Permit2 contract Uniswap, 1inch, and most major DeFi apps use \u2014 it is not exotic infrastructure. The approval alone does not move funds; each subsequent payment still needs a fresh signature. Revocable any time via `twak erc20 revoke`. For first-time use of an endpoint you SHOULD tell the user concretely what is about to happen (one-time approval on <chain> for <token>, gas paid in the chain native token, then the payment) and get their go-ahead before calling. After the approval lands, subsequent Permit2 payments for that token are free of further approvals. Set autoApprove=false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead of broadcasting \u2014 useful when the user is not around or you want to handle the approval out-of-band. maxPaymentAtomic is the user's pre-commitment to a maximum payment in the asset's smallest unit (e.g. \"10000\" = 0.01 USDC at 6 decimals). If the server demands more than this cap, the call returns code: 'PAYMENT_AMOUNT_EXCEEDED' \u2014 DO NOT retry with a higher cap without asking the user. BALANCE CHECK \u2014 Before calling this action, verify the wallet holds enough of the chosen asset on the chosen chain. Call `get_address(chain)` to find the wallet address, then `get_balance` for the asset (or `wallet_balance(chain)` for native coins). For Permit2 first-time use, also confirm the wallet holds some native chain gas (amount varies by chain). Surface insufficient balance to the user BEFORE calling this action \u2014 a failed payment mid-flow can leave the wallet in a half-state (e.g. Permit2 approval broadcast, then the transfer signature fails). The balance check should already have happened during the `x402_quote` flow that produced the menu; redo it here only if you skipped quote or the balance might have changed since. WALLET \u2014 Signs through whichever wallet mode is active for this session (local by default; switchable via `switch_wallet_mode`). If mode='local', signs in-process (no external prompt). If mode='walletconnect', signs over the WalletConnect relay \u2014 the user must approve each signature on their paired wallet. To retrieve the active wallet's address for a chain (e.g. to call `wallet_balance` / `get_balance`), call `get_address` with the chain key (e.g. \"bsc\", \"base\"), or `list_addresses` for all chains at once. HTTPS-only; non-HTTPS schemes and private IPs are rejected before any payment signing.",
       schema: import_zod14.z.object({
         url: import_zod14.z.string().describe(
           "Target endpoint URL. Must be HTTPS. Resolves via DNS; private/local IPs are rejected before any payment."
@@ -45572,8 +46288,8 @@ var WalletModeActionProvider = class extends ActionProvider {
             "WalletConnect is not configured. Set WALLETCONNECT_PROJECT_ID (env var or `twak init --wc-project-id <id>`) and restart the MCP server."
           );
         }
-        const wc2 = this.walletConnectFactory();
-        await this.walletContext.beginWalletConnect(wc2);
+        const wc3 = this.walletConnectFactory();
+        await this.walletContext.beginWalletConnect(wc3);
         return this.snapshotResponse(this.walletContext.snapshot());
       }
     };
@@ -50224,7 +50940,6 @@ var StdioServerTransport = class {
 init_dist();
 var import_http = require("http");
 var import_crypto7 = require("crypto");
-init_dist2();
 init_dist();
 var SERVER_INSTRUCTIONS = `twak signs blockchain operations through one of two wallet modes:
 
@@ -50309,263 +51024,18 @@ var TwakMcpServer = class {
     await this.server.connect(transport);
   }
 };
-var CAIP2_TO_CHAIN = {
-  "eip155:1": "ethereum",
-  "eip155:56": "smartchain",
-  "eip155:137": "polygon",
-  "eip155:42161": "arbitrum",
-  "eip155:8453": "base",
-  "eip155:10": "optimism",
-  "eip155:43114": "avalanche"
-};
-var CAIP2_TO_BC_CHAIN = {
-  "eip155:1": "ethereum",
-  "eip155:56": "bsc",
-  "eip155:137": "polygon",
-  "eip155:42161": "arbitrum",
-  "eip155:8453": "base",
-  "eip155:10": "optimism",
-  "eip155:43114": "avalanche"
-};
-var RPC_REGISTRY = {
-  "eip155:1": {
-    rpc: "https://eth.llamarpc.com",
-    native: "eth",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6 },
-      usdt: { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6 },
-      dai: { address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", decimals: 18 }
-    }
-  },
-  "eip155:56": {
-    rpc: "https://bsc-rpc.publicnode.com",
-    native: "bnb",
-    nativeDecimals: 18,
-    tokens: {
-      usdt: { address: "0x55d398326f99059fF775485246999027B3197955", decimals: 18 },
-      usdc: { address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", decimals: 18 },
-      twt: { address: "0x4B0F1812e5Df2A09796481Ff14017e6005508003", decimals: 18 }
-    }
-  },
-  "eip155:137": {
-    rpc: "https://rpc-mainnet.matic.quiknode.pro",
-    native: "matic",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", decimals: 6 },
-      usdt: { address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", decimals: 6 }
-    }
-  },
-  "eip155:42161": {
-    rpc: "https://arb1.arbitrum.io/rpc",
-    native: "eth",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", decimals: 6 },
-      usdt: { address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", decimals: 6 }
-    }
-  },
-  "eip155:8453": {
-    rpc: "https://mainnet.base.org",
-    native: "eth",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6 },
-      dai: { address: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb", decimals: 18 }
-    }
-  },
-  "eip155:10": {
-    rpc: "https://mainnet.optimism.io",
-    native: "eth",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85", decimals: 6 },
-      usdt: { address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58", decimals: 6 }
-    }
-  },
-  "eip155:43114": {
-    rpc: "https://api.avax.network/ext/bc/C/rpc",
-    native: "avax",
-    nativeDecimals: 18,
-    tokens: {
-      usdc: { address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", decimals: 6 },
-      usdt: { address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7", decimals: 6 }
-    }
-  }
-};
-var TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
-function parseTokenAmount(amount, decimals) {
-  const [int, frac = ""] = amount.split(".");
-  const fracNorm = frac.slice(0, decimals).padEnd(decimals, "0");
-  return BigInt(int || "0") * 10n ** BigInt(decimals) + BigInt(fracNorm || "0");
-}
-async function jsonRpc(rpcUrl, method, params) {
-  const res = await fetch(rpcUrl, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params })
-  });
-  if (!res.ok) throw new Error(`RPC HTTP ${res.status}`);
-  const data = await res.json();
-  if (data.error) throw new Error(data.error.message);
-  return data.result;
-}
-async function verifyViaRPC(txHash, config, chainId) {
-  const chain2 = RPC_REGISTRY[chainId];
-  if (!chain2) return { valid: false, error: `No RPC available for chain ${chainId}` };
-  const assetKey = config.asset.toLowerCase();
-  const isNative = assetKey === chain2.native;
-  const tokenInfo = isNative ? null : chain2.tokens[assetKey];
-  if (!isNative && !tokenInfo) {
-    return { valid: false, error: `Unsupported asset "${config.asset}" on chain ${chainId}` };
-  }
-  const decimals = isNative ? chain2.nativeDecimals : tokenInfo.decimals;
-  const expectedAmount = parseTokenAmount(config.amount, decimals);
-  const recipientLower = config.recipient.toLowerCase();
-  let receipt;
-  try {
-    receipt = await jsonRpc(chain2.rpc, "eth_getTransactionReceipt", [txHash]);
-  } catch (err) {
-    const msg = err instanceof Error ? err.message : String(err);
-    if (msg === "no response" || msg.toLowerCase().includes("not found")) {
-      return { valid: false, error: "Transaction not found or not yet mined" };
-    }
-    return { valid: false, error: `RPC error: ${msg}` };
-  }
-  if (!receipt) return { valid: false, error: "Transaction not found or not yet mined" };
-  if (receipt.status !== "0x1") return { valid: false, error: "Transaction reverted on-chain" };
-  if (isNative) {
-    const tx = await jsonRpc(chain2.rpc, "eth_getTransactionByHash", [txHash]);
-    if (!tx) return { valid: false, error: "Transaction data not found" };
-    if (config.recipient && tx.to?.toLowerCase() !== recipientLower) {
-      return { valid: false, error: "Payment recipient mismatch" };
-    }
-    if (BigInt(tx.value || "0x0") < expectedAmount) {
-      return { valid: false, error: "Insufficient native payment" };
-    }
-    return { valid: true, method: "rpc" };
-  }
-  const tokenAddr = tokenInfo.address.toLowerCase();
-  const recipientPadded = recipientLower.replace("0x", "").padStart(64, "0");
-  const transferLog = receipt.logs?.find(
-    (log) => log.address.toLowerCase() === tokenAddr && log.topics[0] === TRANSFER_TOPIC && (!config.recipient || log.topics[2]?.toLowerCase() === `0x${recipientPadded}`)
-  );
-  if (!transferLog) return { valid: false, error: "No matching Transfer event found" };
-  if (BigInt(transferLog.data) < expectedAmount) {
-    return { valid: false, error: "Insufficient ERC-20 payment" };
-  }
-  return { valid: true, method: "rpc" };
-}
-async function verifyPayment(rawHeader, config, httpClient, seenHashes, blockchainClient) {
-  const header = Array.isArray(rawHeader) ? rawHeader[0] : rawHeader;
-  let proof;
-  try {
-    proof = JSON.parse(Buffer.from(header, "base64").toString("utf8"));
-  } catch {
-    return { valid: false, error: "Invalid payment header: expected base64-encoded JSON" };
-  }
-  if (!proof.txHash || typeof proof.txHash !== "string") {
-    return { valid: false, error: "Missing txHash in payment proof" };
-  }
-  const txHash = proof.txHash;
-  if (await seenHashes.hasSeen(txHash)) {
-    return { valid: false, error: "Transaction hash already used (replay attack detected)" };
-  }
-  if (typeof proof.chainId === "string" && proof.chainId.toLowerCase() !== config.chainId.toLowerCase()) {
-    return {
-      valid: false,
-      error: `Payment chain mismatch \u2014 merchant configured ${config.chainId}, proof claims ${proof.chainId}`
-    };
-  }
-  const chainId = config.chainId.toLowerCase();
-  const chainKey = CAIP2_TO_CHAIN[chainId];
-  if (!chainKey) {
-    return { valid: false, error: `Unsupported chain: ${chainId}` };
-  }
-  const bcChainKey = CAIP2_TO_BC_CHAIN[chainId];
-  if (blockchainClient && bcChainKey) {
-    try {
-      const status = await blockchainClient.findTransactionStatus(
-        bcChainKey,
-        config.recipient || "0x0000000000000000000000000000000000000000",
-        txHash
-      );
-      if (status.failed) {
-        return {
-          valid: false,
-          error: `Transaction reverted on-chain${status.error ? `: ${status.error}` : ""}`
-        };
-      }
-      if (status.confirmed) {
-        const rpcResult2 = await verifyViaRPC(txHash, config, chainId);
-        if (rpcResult2.valid) {
-          await seenHashes.markSeen(txHash, chainId);
-        }
-        return rpcResult2;
-      }
-    } catch {
-    }
-  }
-  const txService = new TransactionService(httpClient);
-  try {
-    const tx = await txService.getByHash(txHash, chainKey);
-    if (!tx) return { valid: false, error: "Transaction not found" };
-    if (tx.status === "pending" || tx.status === "failed") {
-      return { valid: false, error: `Transaction is not confirmed (status: ${tx.status})` };
-    }
-    if (config.recipient && tx.to?.toLowerCase() !== config.recipient.toLowerCase()) {
-      return { valid: false, error: "Payment recipient mismatch" };
-    }
-    const chain2 = RPC_REGISTRY[chainId];
-    const assetKey = config.asset.toLowerCase();
-    const isNative = chain2 && assetKey === chain2.native;
-    const tokenInfo = chain2 && !isNative ? chain2.tokens[assetKey] : void 0;
-    const decimals = isNative ? chain2.nativeDecimals : tokenInfo?.decimals ?? 18;
-    const expectedAtomic = parseTokenAmount(config.amount, decimals);
-    if (BigInt(tx.amount) < expectedAtomic) {
-      return {
-        valid: false,
-        error: `Insufficient payment: received ${tx.amount}, expected ${config.amount}`
-      };
-    }
-    await seenHashes.markSeen(txHash, chainId);
-    return { valid: true, method: "txhub" };
-  } catch (err) {
-    const is403 = err instanceof Error && err.message.includes("403");
-    if (!is403) {
-      return {
-        valid: false,
-        error: `Failed to fetch transaction: ${err instanceof Error ? err.message : String(err)}`
-      };
-    }
-  }
-  const rpcResult = await verifyViaRPC(txHash, config, chainId);
-  if (rpcResult.valid) {
-    await seenHashes.markSeen(txHash, chainId);
-  }
-  return rpcResult;
-}
 var TwakRestServer = class {
   registry;
   context;
   config;
-  seenHashes;
   httpServer = null;
   constructor(registry, context, config = {}) {
     this.registry = registry;
     this.context = context;
-    this.seenHashes = new SeenHashStore();
     this.config = {
       port: config.port ?? 3e3,
       host: config.host ?? "127.0.0.1",
-      apiKey: config.apiKey,
-      paymentRequired: config.paymentRequired ?? false,
-      paymentAsset: config.paymentAsset ?? "usdc",
-      paymentAmount: config.paymentAmount ?? "0.01",
-      paymentChainId: config.paymentChainId ?? "eip155:8453",
-      paymentRecipient: config.paymentRecipient ?? "",
-      blockchainClient: config.blockchainClient ?? void 0
+      apiKey: config.apiKey
     };
   }
   start() {
@@ -50589,11 +51059,6 @@ var TwakRestServer = class {
         } else {
           console.error("WARNING: No API key configured \u2014 REST server is unauthenticated");
         }
-        if (this.config.paymentRequired) {
-          console.error(
-            `x402 payment required: ${this.config.paymentAmount} ${this.config.paymentAsset} on ${this.config.paymentChainId}`
-          );
-        }
         resolve2();
       });
     });
@@ -50623,7 +51088,7 @@ var TwakRestServer = class {
     } catch {
     }
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment, Authorization");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, Authorization");
     if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
@@ -50662,52 +51127,6 @@ var TwakRestServer = class {
       return;
     }
     const actionName = match[1];
-    if (this.config.paymentRequired) {
-      const paymentHeader = req.headers["x-payment"];
-      if (!paymentHeader) {
-        res.setHeader(
-          "WWW-Authenticate",
-          `x402 realm="twak", asset="${this.config.paymentAsset}", amount="${this.config.paymentAmount}", chain="${this.config.paymentChainId}"`
-        );
-        res.writeHead(402);
-        res.end(
-          JSON.stringify({
-            error: "payment_required",
-            message: `This endpoint requires payment of ${this.config.paymentAmount} ${this.config.paymentAsset}`,
-            asset: this.config.paymentAsset,
-            amount: this.config.paymentAmount,
-            chainId: this.config.paymentChainId,
-            recipient: this.config.paymentRecipient || void 0
-          })
-        );
-        return;
-      }
-      if (this.config.paymentRecipient) {
-        const result = await verifyPayment(
-          paymentHeader,
-          {
-            asset: this.config.paymentAsset,
-            amount: this.config.paymentAmount,
-            chainId: this.config.paymentChainId,
-            recipient: this.config.paymentRecipient
-          },
-          this.context.httpClient,
-          this.seenHashes,
-          this.config.blockchainClient
-        );
-        if (!result.valid) {
-          res.writeHead(402);
-          res.end(
-            JSON.stringify({
-              error: "payment_verification_failed",
-              message: result.error ?? "Payment could not be verified"
-            })
-          );
-          return;
-        }
-      }
-      console.error(`[x402] Payment verified for ${actionName}`);
-    }
     const action = this.registry.getAction(actionName);
     if (!action) {
       res.writeHead(404);
@@ -50747,14 +51166,6 @@ function registerServeCommand(program3) {
   program3.command("serve").description("Start MCP server (stdio) or REST API server for AI agent connection").option("--rest", "Start REST HTTP server instead of MCP stdio server").option("--port <n>", "Port for REST server", "3000").option(
     "--host <host>",
     "Host to bind REST server (default: 127.0.0.1; use 0.0.0.0 to expose externally)"
-  ).option("--x402", "Require x402 micropayment for REST endpoints").option("--payment-amount <n>", "Payment amount required per request", "0.01").option("--payment-asset <asset>", "Payment asset (usdc, eth, twt, bnb, matic, ...)", "usdc").option(
-    "--payment-chain <chainId>",
-    "Payment chain ID (e.g. eip155:56 for BSC/TWT, eip155:8453 for Base)",
-    "eip155:8453"
-  ).option(
-    "--payment-recipient <address>",
-    "Address to receive payments (required for on-chain verification)",
-    ""
   ).option("--password <password>", "Wallet password (falls back to keychain)").option("--auto-lock <minutes>", "Auto-lock wallet after N minutes of inactivity").option("--wc-project-id <id>", "WalletConnect project ID (or set WALLETCONNECT_PROJECT_ID)").action(async (opts) => {
     await ensureTrustSDK();
     const client = await getClient();
@@ -50791,6 +51202,7 @@ function registerServeCommand(program3) {
     const walletContext = new WalletContext();
     if (agentWallet) {
       await walletContext.bindLocal(agentWallet);
+      blockchainClient.setSigner(agentWallet.getSigner());
     }
     const registry = new ActionRegistry();
     registry.register(new BalanceActionProvider());
@@ -50800,12 +51212,16 @@ function registerServeCommand(program3) {
     registry.register(new SwapActionProvider(swapClient, walletContext, blockchainClient));
     registry.register(new SecurityActionProvider());
     registry.register(new HistoryActionProvider());
-    registry.register(new TransferActionProvider(walletContext, swapClient));
+    registry.register(
+      new TransferActionProvider(walletContext, swapClient, void 0, blockchainClient)
+    );
     registry.register(new AlertActionProvider(alertStore, swapClient));
     registry.register(new AgentWalletActionProvider(blockchainClient, walletContext));
     registry.register(new TokenActionProvider(blockchainClient, walletContext));
     registry.register(new MarketActionProvider());
-    registry.register(new OnrampActionProvider(walletContext, swapClient));
+    registry.register(
+      new OnrampActionProvider(walletContext, swapClient, void 0, blockchainClient)
+    );
     registry.register(
       new AutomateActionProvider(automationStore, swapClient, walletContext, blockchainClient)
     );
@@ -50817,13 +51233,7 @@ function registerServeCommand(program3) {
       const restServer = new TwakRestServer(registry, context, {
         port: parseInt(opts.port),
         host: opts.host,
-        apiKey: client.hmacSecret,
-        paymentRequired: opts.x402,
-        paymentAsset: opts.paymentAsset,
-        paymentAmount: opts.paymentAmount,
-        paymentChainId: opts.paymentChain,
-        paymentRecipient: opts.paymentRecipient,
-        blockchainClient
+        apiKey: client.hmacSecret
       });
       registerShutdownHandlers([agentWallet], async () => {
         await walletContext.reset();
@@ -51240,7 +51650,7 @@ ${url}`);
       } catch (err) {
         mapBroadcastError(err);
       }
-      const explorerUrl = getExplorerTxUrl(result.chainKey, result.hash);
+      const explorerUrl = getExplorerTxUrl(result.chainKey, result.txHash);
       success("Off-ramp payout broadcast!");
       if (!opts.json) {
         info(
@@ -51249,7 +51659,7 @@ ${url}`);
       }
       output(
         {
-          hash: result.hash,
+          hash: result.txHash,
           chain: result.chainKey,
           from: address,
           to: opts.to,
@@ -51751,7 +52161,7 @@ var crypto7 = __toESM(require("crypto"));
 // package.json
 var package_default = {
   name: "@trustwallet/cli",
-  version: "0.14.0",
+  version: "0.15.0",
   description: "TWAK CLI \u2014 command-line interface for Trust Wallet Agent Kit",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -51786,7 +52196,7 @@ var package_default = {
   },
   devDependencies: {
     "@twak/actions": "workspace:*",
-    "@twak/blockchain": "workspace:*",
+    "@twak/contracts": "workspace:*",
     "@twak/core": "workspace:*",
     "@twak/mcp": "workspace:*",
     "@twak/security": "workspace:*",
@@ -51919,7 +52329,7 @@ function registerTelemetryCommand(program3) {
 // src/commands/watch.ts
 init_dist();
 init_dist2();
-init_dist4();
+init_dist3();
 function ts3() {
   return (/* @__PURE__ */ new Date()).toISOString().replace("T", " ").slice(0, 19);
 }