@trustwallet/cli 0.23.0 → 0.24.1

package/dist/index.js

@@ -1046,7 +1046,7 @@ var require_command = __commonJS({
     "use strict";
     var EventEmitter = require("events").EventEmitter;
     var childProcess = require("child_process");
-    var path7 = require("path");
+    var path13 = require("path");
     var fs10 = require("fs");
     var process3 = require("process");
     var { Argument: Argument2, humanReadableArgName } = require_argument();
@@ -1979,9 +1979,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
         let launchWithNode = false;
         const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
         function findFile(baseDir, baseName) {
-          const localBin = path7.resolve(baseDir, baseName);
+          const localBin = path13.resolve(baseDir, baseName);
           if (fs10.existsSync(localBin)) return localBin;
-          if (sourceExt.includes(path7.extname(baseName))) return void 0;
+          if (sourceExt.includes(path13.extname(baseName))) return void 0;
           const foundExt = sourceExt.find(
             (ext) => fs10.existsSync(`${localBin}${ext}`)
           );
@@ -1999,17 +1999,17 @@ Expecting one of '${allowedValues.join("', '")}'`);
           } catch (err) {
             resolvedScriptPath = this._scriptPath;
           }
-          executableDir = path7.resolve(
-            path7.dirname(resolvedScriptPath),
+          executableDir = path13.resolve(
+            path13.dirname(resolvedScriptPath),
             executableDir
           );
         }
         if (executableDir) {
           let localFile = findFile(executableDir, executableFile);
           if (!localFile && !subcommand._executableFile && this._scriptPath) {
-            const legacyName = path7.basename(
+            const legacyName = path13.basename(
               this._scriptPath,
-              path7.extname(this._scriptPath)
+              path13.extname(this._scriptPath)
             );
             if (legacyName !== this._name) {
               localFile = findFile(
@@ -2020,7 +2020,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
           }
           executableFile = localFile || executableFile;
         }
-        launchWithNode = sourceExt.includes(path7.extname(executableFile));
+        launchWithNode = sourceExt.includes(path13.extname(executableFile));
         let proc;
         if (process3.platform !== "win32") {
           if (launchWithNode) {
@@ -2860,7 +2860,7 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command}
        */
       nameFromFilename(filename) {
-        this._name = path7.basename(filename, path7.extname(filename));
+        this._name = path13.basename(filename, path13.extname(filename));
         return this;
       }
       /**
@@ -2874,9 +2874,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @param {string} [path]
        * @return {(string|null|Command)}
        */
-      executableDir(path8) {
-        if (path8 === void 0) return this._executableDir;
-        this._executableDir = path8;
+      executableDir(path14) {
+        if (path14 === void 0) return this._executableDir;
+        this._executableDir = path14;
         return this;
       }
       /**
@@ -3108,213 +3108,13 @@ var require_commander = __commonJS({
 });
 
 // ../core/dist/index.mjs
-var dist_exports = {};
-__export(dist_exports, {
-  ALERT_ERROR_CODES: () => ALERT_ERROR_CODES,
-  ALLOWED_OFFRAMP_PROVIDERS: () => ALLOWED_OFFRAMP_PROVIDERS,
-  AUTOMATION_ERROR_CODES: () => AUTOMATION_ERROR_CODES,
-  AlertError: () => AlertError,
-  AutomationError: () => AutomationError,
-  BALANCE_ERROR_CODES: () => BALANCE_ERROR_CODES,
-  BalanceError: () => BalanceError,
-  CELO_NATIVE_ADDRESS: () => CELO_NATIVE_ADDRESS,
-  CHAINS: () => CHAINS,
-  COMMON_ERROR_CODES: () => COMMON_ERROR_CODES,
-  COMMON_TOKENS: () => COMMON_TOKENS,
-  CommandError: () => CommandError,
-  DEFAULT_USER_AGENT: () => DEFAULT_USER_AGENT,
-  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,
-  QUERY_ERROR_CODES: () => QUERY_ERROR_CODES,
-  QueryError: () => QueryError,
-  SOLANA_NATIVE_ADDRESS: () => SOLANA_NATIVE_ADDRESS,
-  SWAP_ERROR_CODES: () => SWAP_ERROR_CODES,
-  SwapError: () => SwapError,
-  TESTNET_CHAINS: () => TESTNET_CHAINS,
-  TRANSFER_ERROR_CODES: () => TRANSFER_ERROR_CODES,
-  TransferError: () => TransferError,
-  TwakApiError: () => TwakApiError,
-  TwakError: () => TwakError,
-  TwakHttpClient: () => TwakHttpClient,
-  TwakNetworkError: () => TwakNetworkError,
-  TwakValidationError: () => TwakValidationError,
-  WALLET_ERROR_CODES: () => WALLET_ERROR_CODES,
-  WATCH_ERROR_CODES: () => WATCH_ERROR_CODES,
-  WalletError: () => WalletError,
-  WatchError: () => WatchError,
-  X402Error: () => X402Error,
-  X402_ERROR_CODES: () => X402_ERROR_CODES,
-  ZERO_ADDRESS: () => ZERO_ADDRESS,
-  assertEvmAddress: () => assertEvmAddress,
-  assertStrictPositiveAmount: () => assertStrictPositiveAmount,
-  chainKeyToCoinType: () => chainKeyToCoinType,
-  classifyApiError: () => classifyApiError,
-  classifyStorageError: () => classifyStorageError,
-  classifyWalletLoadError: () => classifyWalletLoadError,
-  coinTypeToChainKey: () => coinTypeToChainKey,
-  createTwakClient: () => createTwakClient,
-  encodeErc20Transfer: () => encodeErc20Transfer,
-  errorMessage: () => errorMessage,
-  fetchBalance: () => fetchBalance,
-  fetchBalances: () => fetchBalances,
-  formatAmount: () => formatAmount,
-  formatTokenId: () => formatTokenId,
-  getChainByCoinId: () => getChainByCoinId,
-  getChainByEvmId: () => getChainByEvmId,
-  getChainById: () => getChainById,
-  getChainDomainId: () => getChainDomainId,
-  getChainMapKey: () => getChainMapKey,
-  getEVMChains: () => getEVMChains,
-  getExplorerTxUrl: () => getExplorerTxUrl,
-  getNativeAddressPlaceholder: () => getNativeAddressPlaceholder,
-  getSampleAccount: () => getSampleAccount,
-  getSupportedChains: () => getSupportedChains,
-  getSupportedCoinTypes: () => getSupportedCoinTypes,
-  isChainSupported: () => isChainSupported,
-  isCoinTypeSupported: () => isCoinTypeSupported,
-  isEvmAddress: () => isEvmAddress,
-  isNativeTokenId: () => isNativeTokenId,
-  isRateLimited: () => isRateLimited,
-  isTestnetChain: () => isTestnetChain,
-  isZeroAddress: () => isZeroAddress,
-  lookupKnownTokenDecimals: () => lookupKnownTokenDecimals,
-  parseAmount: () => parseAmount,
-  parseTokenId: () => parseTokenId,
-  rankQuotesByBest: () => rankQuotesByBest,
-  requireChain: () => requireChain,
-  resolveAddress: () => resolveAddress,
-  resolveAddressOrName: () => resolveAddressOrName,
-  resolveAsset: () => resolveAsset,
-  resolveChain: () => resolveChain,
-  resolveDecimals: () => resolveDecimals,
-  resolveName: () => resolveName,
-  resolveToken: () => resolveToken,
-  signRequest: () => signRequest,
-  sortQueryParams: () => sortQueryParams,
-  sortQueryParamsGoCompat: () => sortQueryParamsGoCompat,
-  toCamelCase: () => toCamelCase,
-  tokenIdToChain: () => tokenIdToChain,
-  tryClassifyError: () => tryClassifyError,
-  withRetry: () => withRetry
-});
-function getChainById(chainKey) {
-  const lower = chainKey.toLowerCase();
-  return CHAINS[lower] ?? TESTNET_CHAINS[lower] ?? Object.values(CHAINS).find((c3) => c3.id === lower) ?? Object.values(TESTNET_CHAINS).find((c3) => c3.id === lower);
-}
-function getChainByCoinId(coinId) {
-  return Object.values(CHAINS).find((chain2) => chain2.coinId === coinId);
-}
-function getChainByEvmId(evmChainId) {
-  return Object.values(CHAINS).find((chain2) => chain2.chainId === evmChainId) ?? Object.values(TESTNET_CHAINS).find((chain2) => chain2.chainId === evmChainId);
-}
-function isTestnetChain(chainKey) {
-  if (!chainKey) return false;
-  return Object.hasOwn(TESTNET_CHAINS, chainKey.toLowerCase());
-}
-function getSupportedChains() {
-  return Object.values(CHAINS);
-}
-function getEVMChains() {
-  return Object.values(CHAINS).filter((chain2) => chain2.isEVM);
-}
-function isChainSupported(chainKey) {
-  return chainKey.toLowerCase() in CHAINS;
-}
-function getChainMapKey(chainKey) {
-  const lower = chainKey.toLowerCase();
-  if (CHAINS[lower]) return lower;
-  const entry = Object.entries(CHAINS).find(([, c3]) => c3.id === lower);
-  return entry?.[0];
-}
-function getChainDomainId(chainKey) {
-  const lower = chainKey.toLowerCase();
-  const chain2 = CHAINS[lower];
-  if (chain2) return chain2.id;
-  const entry = Object.entries(CHAINS).find(([, c3]) => c3.id === lower);
-  if (!entry) throw new Error(`Unsupported chain: ${chainKey}`);
-  return entry[1].id;
-}
-function getExplorerTxUrl(chainKey, hash) {
-  const chain2 = getChainById(chainKey);
-  if (!chain2) return "";
-  return `${chain2.explorerUrl}/tx/${hash}`;
-}
-function getSampleAccount(chainKey) {
-  return getChainById(chainKey)?.sampleAccount || "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045";
-}
-function getNativeAddressPlaceholder(chainKey) {
-  const chain2 = getChainById(chainKey);
-  if (!chain2) return NATIVE_TOKEN_ADDRESS;
-  if (chain2.namespace === "solana") return SOLANA_NATIVE_ADDRESS;
-  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()
+function toRegistry(definitions) {
+  return Object.fromEntries(
+    Object.entries(definitions).map(([key, d3]) => [
+      key,
+      { ...d3, id: d3.id, coinId: d3.coinId }
+    ])
   );
-  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 found = Object.entries(CHAINS).find(([, c3]) => c3.coinId === coinId);
-    if (found) {
-      const [, chain2] = found;
-      if (contractAddress) {
-        return { address: contractAddress };
-      }
-      return { address: getNativeAddressPlaceholder(chain2.id) };
-    }
-  }
-  const upperToken = token.toUpperCase();
-  const chainConfig = getChainById(chainKey);
-  const mapKey = getChainMapKey(chainKey) ?? chainKey.toLowerCase();
-  const chainTokens = COMMON_TOKENS[mapKey];
-  if (chainTokens?.[upperToken]) {
-    return { address: chainTokens[upperToken].address };
-  }
-  if (NATIVE_SYMBOLS.has(upperToken) || chainConfig && upperToken === chainConfig.symbol.toUpperCase()) {
-    return { address: getNativeAddressPlaceholder(chainKey) };
-  }
-  if (upperToken.startsWith("USDC")) {
-    const entry = chainTokens?.["USDC.e"] || chainTokens?.["USDC"];
-    if (!entry) return null;
-    return { address: entry.address };
-  }
-  if (upperToken.startsWith("USDT")) {
-    const entry = chainTokens?.["USDT"];
-    if (!entry) return null;
-    return { address: entry.address };
-  }
-  if (token.startsWith("0x") || token.length > 20) {
-    return { address: token };
-  }
-  return null;
-}
-function chainKeyToCoinType(chainKey) {
-  const key = chainKey.toLowerCase();
-  return (CHAINS[key] ?? Object.values(CHAINS).find((c3) => c3.id.toLowerCase() === key))?.coinId;
-}
-function coinTypeToChainKey(coinType) {
-  return Object.entries(CHAINS).find(([, chain2]) => chain2.coinId === coinType)?.[0];
-}
-function getSupportedCoinTypes() {
-  return Object.values(CHAINS).map((chain2) => chain2.coinId);
-}
-function isCoinTypeSupported(coinType) {
-  return Object.values(CHAINS).some((chain2) => chain2.coinId === coinType);
 }
 function errorMessage(err) {
   if (err instanceof Error) return err.message;
@@ -3441,14 +3241,121 @@ function parseTokenId(id) {
   const contractAddress = match[2] || void 0;
   return { coinId, contractAddress };
 }
-function isNativeTokenId(id) {
-  return /^c\d+$/.test(id);
+function chainOf(chainKey) {
+  return REGISTRY[chainKey];
+}
+function isTestnet(chainKey) {
+  return Object.hasOwn(TESTNET_CHAINS, chainKey);
+}
+function coinIdOf(chainKey) {
+  return chainOf(chainKey).coinId;
+}
+function evmChainIdOf(chainKey) {
+  const chain2 = chainOf(chainKey);
+  if (chain2.namespace !== "eip155") {
+    throw new WalletError("CHAIN_UNSUPPORTED", `${chainKey} is not an EVM chain`);
+  }
+  return Number(chain2.chainId);
+}
+function caip2Of(chainKey) {
+  const chain2 = chainOf(chainKey);
+  return `${chain2.namespace}:${chain2.chainId}`;
+}
+function backendIdOf(chainKey) {
+  return chainOf(chainKey).id;
+}
+function assetIdOf(chainKey, tokenAddress) {
+  return formatTokenId(coinIdOf(chainKey), tokenAddress);
+}
+function allChainKeys() {
+  return Object.keys(REGISTRY);
+}
+function knownChainKey(key) {
+  if (!Object.hasOwn(REGISTRY, key)) throw new Error(`Not a chain key: "${key}"`);
+  return key;
+}
+function byChainKey(entries) {
+  for (const key of Object.keys(entries)) knownChainKey(key);
+  return entries;
+}
+function mainnetChainKeys() {
+  return Object.keys(CHAINS);
+}
+function mainnetChainKeysWhere(predicate) {
+  return mainnetChainKeys().filter((key) => predicate(chainOf(key)));
+}
+function chainKeysWithKnownTokens() {
+  return Object.keys(COMMON_TOKENS);
+}
+function testnetChainKeys() {
+  return Object.keys(TESTNET_CHAINS);
+}
+function mainnetChainKeyForCoinId(coinId) {
+  return mainnetChainKeys().find((key) => chainOf(key).coinId === coinId);
+}
+function chainKeyForCaip2(caip2) {
+  return allChainKeys().find((key) => caip2Of(key) === caip2) ?? null;
+}
+function chainKeyForBackendId(backendId) {
+  return allChainKeys().find((key) => backendIdOf(key) === backendId);
+}
+function getExplorerTxUrl(chainKey, hash) {
+  return `${chainOf(chainKey).explorerUrl}/tx/${hash}`;
+}
+function getSampleAccount(chainKey) {
+  return chainOf(chainKey).sampleAccount;
+}
+function getNativeAddressPlaceholder(chainKey) {
+  const chain2 = chainOf(chainKey);
+  if (chain2.namespace === "solana") return SOLANA_NATIVE_ADDRESS;
+  if (chain2.id === "celo") return CELO_NATIVE_ADDRESS;
+  return NATIVE_TOKEN_ADDRESS;
+}
+function lookupKnownTokenDecimals(chainKey, tokenAddress) {
+  if (!tokenAddress) return chainOf(chainKey).decimals;
+  const registry = COMMON_TOKENS[chainKey] ?? {};
+  const entry = Object.values(registry).find(
+    (e2) => e2.address.toLowerCase() === tokenAddress.toLowerCase()
+  );
+  return entry?.decimals;
+}
+function resolveToken(token, chainKey) {
+  if (/^c\d+(?:_t.+)?$/.test(token)) {
+    const { coinId, contractAddress } = parseTokenId(token);
+    const assetChain = mainnetChainKeyForCoinId(coinId);
+    if (assetChain) {
+      if (contractAddress) {
+        return { address: contractAddress };
+      }
+      return { address: getNativeAddressPlaceholder(assetChain) };
+    }
+  }
+  const upperToken = token.toUpperCase();
+  const chainConfig = chainOf(chainKey);
+  const chainTokens = COMMON_TOKENS[chainKey];
+  if (chainTokens?.[upperToken]) {
+    return { address: chainTokens[upperToken].address };
+  }
+  if (NATIVE_SYMBOLS.has(upperToken) || upperToken === chainConfig.symbol.toUpperCase()) {
+    return { address: getNativeAddressPlaceholder(chainKey) };
+  }
+  if (upperToken.startsWith("USDC")) {
+    const entry = chainTokens?.["USDC.e"] || chainTokens?.["USDC"];
+    if (!entry) return null;
+    return { address: entry.address };
+  }
+  if (upperToken.startsWith("USDT")) {
+    const entry = chainTokens?.["USDT"];
+    if (!entry) return null;
+    return { address: entry.address };
+  }
+  if (token.startsWith("0x") || token.length > 20) {
+    return { address: token };
+  }
+  return null;
 }
 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];
+  return mainnetChainKeyForCoinId(parseTokenId(id).coinId);
 }
 function resolveChain(input2) {
   if (typeof input2 !== "string" || input2.trim().length === 0) {
@@ -3462,7 +3369,8 @@ function resolveChain(input2) {
   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(RESOLVABLE_CHAINS)) {
+    for (const key of RESOLVABLE_KEYS) {
+      const chain2 = REGISTRY[key];
       if (chain2.namespace === namespace && chain2.chainId.toLowerCase() === reference) {
         return key;
       }
@@ -3474,17 +3382,17 @@ function resolveChain(input2) {
     const underscoreIdx = rest.indexOf("_");
     const coinStr = underscoreIdx === -1 ? rest : rest.slice(0, underscoreIdx);
     if (/^\d+$/.test(coinStr)) {
-      const key = coinTypeToChainKey(Number(coinStr));
+      const key = mainnetChainKeyForCoinId(Number(coinStr));
       if (key) return key;
       throw chainUnsupported(input2);
     }
   }
-  if (RESOLVABLE_CHAINS[lower]) return lower;
+  const direct = RESOLVABLE_KEYS.find((key) => key === lower);
+  if (direct) return direct;
   const aliased = ALIASES[lower];
   if (aliased) return aliased;
-  for (const [key, chain2] of Object.entries(RESOLVABLE_CHAINS)) {
-    if (chain2.id === lower) return key;
-  }
+  const byId = RESOLVABLE_KEYS.find((key) => REGISTRY[key].id === lower);
+  if (byId) return byId;
   if (/^0x[0-9a-f]+$/.test(lower)) {
     const key = lookupEvm(parseInt(lower, 16).toString());
     if (key) return key;
@@ -3495,15 +3403,13 @@ function resolveChain(input2) {
   throw chainUnsupported(input2);
 }
 function lookupEvm(chainId) {
-  for (const [key, chain2] of Object.entries(RESOLVABLE_CHAINS)) {
-    if (chain2.namespace === "eip155" && chain2.chainId === chainId) return key;
-  }
-  return void 0;
+  return RESOLVABLE_KEYS.find(
+    (key) => REGISTRY[key].namespace === "eip155" && REGISTRY[key].chainId === chainId
+  );
 }
 function resolveAsset(chain2, tokenAddress) {
   const chainKey = resolveChain(chain2);
-  const coinId = RESOLVABLE_CHAINS[chainKey].coinId;
-  return { chainKey, coinId, assetId: formatTokenId(coinId, tokenAddress) };
+  return { chainKey, coinId: coinIdOf(chainKey), assetId: assetIdOf(chainKey, tokenAddress) };
 }
 function chainUnsupported(input2) {
   const suggestions = suggest(input2);
@@ -3558,39 +3464,6 @@ async function resolveAddress(search, chain2, params) {
   const match = matches.find((m2) => m2.address.toLowerCase() === address.toLowerCase());
   return match?.address || address;
 }
-function sortQueryParams(query) {
-  if (!query) return query;
-  const queryParams = new URLSearchParams(query);
-  const keys2 = Array.from(queryParams.keys());
-  keys2.sort();
-  const uniqueKeys = Array.from(new Set(keys2));
-  const sortedParams = new URLSearchParams();
-  for (const key of uniqueKeys) {
-    const values = queryParams.getAll(key);
-    for (const value of values) {
-      sortedParams.append(key, value);
-    }
-  }
-  return sortedParams.toString();
-}
-function goQueryEscape(str) {
-  return encodeURIComponent(str).replace(/%20/g, "+").replace(/\*/g, "%2A").replace(/!/g, "%21").replace(/'/g, "%27").replace(/\(/g, "%28").replace(/\)/g, "%29");
-}
-function sortQueryParamsGoCompat(query) {
-  if (!query) return query;
-  const queryParams = new URLSearchParams(query);
-  const keys2 = Array.from(queryParams.keys());
-  keys2.sort();
-  const uniqueKeys = Array.from(new Set(keys2));
-  const parts = [];
-  for (const key of uniqueKeys) {
-    const values = queryParams.getAll(key);
-    for (const value of values) {
-      parts.push(`${goQueryEscape(key)}=${goQueryEscape(value)}`);
-    }
-  }
-  return parts.join("&");
-}
 function formatAmount(amount, decimals) {
   const value = BigInt(amount);
   const divisor = 10n ** BigInt(decimals);
@@ -3656,6 +3529,10 @@ async function resolveAddressOrName(value) {
   if (!resolved) throw new Error(`Could not resolve name: ${value}`);
   return resolved;
 }
+function twakHome(env = process.env) {
+  const configured = env.TWAK_HOME?.trim();
+  return configured ? path.resolve(configured) : path.join(os.homedir(), ".twak");
+}
 function isEvmAddress(value) {
   return EVM_ADDRESS_RE.test(value);
 }
@@ -3670,19 +3547,6 @@ function assertEvmAddress(value, label) {
     );
   }
 }
-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 requireChain(chainKey) {
-  const chain2 = getChainById(chainKey);
-  if (!chain2) {
-    throw new TwakValidationError(`Unknown chain: ${chainKey}`, { chainKey });
-  }
-  return chain2;
-}
 function sortQueryRaw(query) {
   if (!query) return query;
   const parts = query.split("&").filter(Boolean);
@@ -3693,11 +3557,11 @@ function sortQueryRaw(query) {
   });
   return parts.join("&");
 }
-function signRequest(method, path7, query, accessId, hmacSecret) {
+function signRequest(method, path23, query, accessId, hmacSecret) {
   const date = (/* @__PURE__ */ new Date()).toUTCString();
   const nonce = (0, import_crypto.randomUUID)();
   const sortedQuery = sortQueryRaw(query);
-  const plaintext = [method.toUpperCase(), path7, sortedQuery, accessId, nonce, date].join(";");
+  const plaintext = [method.toUpperCase(), path23, sortedQuery, accessId, nonce, date].join(";");
   const signature = (0, import_crypto.createHmac)("sha256", hmacSecret).update(plaintext).digest("base64");
   return {
     "X-TW-CREDENTIAL": accessId,
@@ -3783,14 +3647,16 @@ 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, TESTNET_CHAINS, COMMON_TOKENS, NATIVE_SYMBOLS, CELO_NATIVE_ADDRESS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, EXECUTION_REVERTED_RE, FS_ERRNO_CODES, commandErrorCodeSet, 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, RESOLVABLE_CHAINS, ALIASES, BARE_EVM_ADDRESS, ASSET_ID_EVM_ADDRESS, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, EVM_ADDRESS_RE, ERC20_TRANSFER_SIG, ZERO_ADDRESS, DEFAULT_GATEWAY_URL, DEFAULT_MARKET_URL, DEFAULT_TIMEOUT, DEFAULT_USER_AGENT, DEFAULT_X_ORIGIN, TwakHttpClient, ALLOWED_OFFRAMP_PROVIDERS, McpResponse;
+var os, path, import_crypto, NATIVE_TOKEN_ADDRESS, SOLANA_NATIVE_ADDRESS, MAINNET_DEFINITIONS, TESTNET_DEFINITIONS, CHAINS, TESTNET_CHAINS, REGISTRY, COMMON_TOKEN_DEFINITIONS, COMMON_TOKENS, TwakError, TwakApiError, TwakNetworkError, TwakValidationError, CommandError, COMMON_ERROR_CODES, EXECUTION_REVERTED_RE, FS_ERRNO_CODES, commandErrorCodeSet, 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, NATIVE_SYMBOLS, CELO_NATIVE_ADDRESS, RESOLVABLE_KEYS, ALIASES, BARE_EVM_ADDRESS, ASSET_ID_EVM_ADDRESS, DECIMAL_AMOUNT_RE, UNSAFE_KEYS, NAMING_API, EVM_ADDRESS_RE, ZERO_ADDRESS, 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";
+    os = __toESM(require("os"), 1);
+    path = __toESM(require("path"), 1);
     import_crypto = require("crypto");
     NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
     SOLANA_NATIVE_ADDRESS = "So11111111111111111111111111111111111111112";
-    CHAINS = {
+    MAINNET_DEFINITIONS = {
       ethereum: {
         id: "ethereum",
         name: "Ethereum",
@@ -4124,7 +3990,7 @@ var init_dist = __esm({
         sampleAccount: "0x8d1f3c7b5e9a2047c6b3d80f1e4a9258c7d6b3e5f8a0c2d4e6f8a0b2c4d6e8f"
       }
     };
-    TESTNET_CHAINS = {
+    TESTNET_DEFINITIONS = {
       bsctestnet: {
         id: "smartchain-testnet",
         name: "BNB Smart Chain Testnet",
@@ -4139,7 +4005,10 @@ var init_dist = __esm({
         sampleAccount: "0x8894E0a0c962CB723c1976a4421c95949bE2D4E3"
       }
     };
-    COMMON_TOKENS = {
+    CHAINS = toRegistry(MAINNET_DEFINITIONS);
+    TESTNET_CHAINS = toRegistry(TESTNET_DEFINITIONS);
+    REGISTRY = { ...CHAINS, ...TESTNET_CHAINS };
+    COMMON_TOKEN_DEFINITIONS = {
       ethereum: {
         USDT: { address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6 },
         USDC: { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6 },
@@ -4207,36 +4076,7 @@ var init_dist = __esm({
         WSOL: { address: "So11111111111111111111111111111111111111112", decimals: 9 }
       }
     };
-    NATIVE_SYMBOLS = /* @__PURE__ */ new Set([
-      "NATIVE",
-      "ETH",
-      "MATIC",
-      "BNB",
-      "AVAX",
-      "FTM",
-      "S",
-      "CELO",
-      // EVM
-      "SOL",
-      // Solana
-      "TRX",
-      // Tron
-      "APT",
-      // Aptos
-      "TON",
-      // TON
-      "SUI",
-      // Sui
-      "NEAR",
-      // NEAR
-      "ATOM",
-      // Cosmos
-      "BTC",
-      "LTC",
-      "DOGE"
-      // Bitcoin family
-    ]);
-    CELO_NATIVE_ADDRESS = "0x471EcE3750Da237f93B8E339c536989b8978a438";
+    COMMON_TOKENS = COMMON_TOKEN_DEFINITIONS;
     TwakError = class extends Error {
       constructor(message, code2, details) {
         super(message);
@@ -4431,7 +4271,37 @@ var init_dist = __esm({
         this.name = "X402Error";
       }
     };
-    RESOLVABLE_CHAINS = { ...CHAINS, ...TESTNET_CHAINS };
+    NATIVE_SYMBOLS = /* @__PURE__ */ new Set([
+      "NATIVE",
+      "ETH",
+      "MATIC",
+      "BNB",
+      "AVAX",
+      "FTM",
+      "S",
+      "CELO",
+      // EVM
+      "SOL",
+      // Solana
+      "TRX",
+      // Tron
+      "APT",
+      // Aptos
+      "TON",
+      // TON
+      "SUI",
+      // Sui
+      "NEAR",
+      // NEAR
+      "ATOM",
+      // Cosmos
+      "BTC",
+      "LTC",
+      "DOGE"
+      // Bitcoin family
+    ]);
+    CELO_NATIVE_ADDRESS = "0x471EcE3750Da237f93B8E339c536989b8978a438";
+    RESOLVABLE_KEYS = Object.keys(REGISTRY);
     ALIASES = {
       "binance-smart-chain": "bsc",
       matic: "polygon",
@@ -4444,7 +4314,6 @@ var init_dist = __esm({
     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";
     ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
     DEFAULT_GATEWAY_URL = "https://tws.trustwallet.com";
     DEFAULT_MARKET_URL = "https://market.trustwallet.com";
@@ -4470,11 +4339,11 @@ var init_dist = __esm({
           this.resolveCredentials = () => fixed;
         }
       }
-      async gateway(method, path7, body, query) {
-        const url = new URL(path7, this.config.gatewayBaseUrl);
+      async gateway(method, path23, body, query) {
+        const url = new URL(path23, this.config.gatewayBaseUrl);
         if (query) url.search = query;
         const { accessId, hmacSecret } = this.resolveCredentials();
-        const headers = signRequest(method, path7, query || "", accessId, hmacSecret);
+        const headers = signRequest(method, path23, query || "", accessId, hmacSecret);
         return this.fetch(url.toString(), {
           method,
           headers: {
@@ -4485,14 +4354,14 @@ var init_dist = __esm({
           body: body ? JSON.stringify(body) : void 0
         });
       }
-      async amber(method, path7, body) {
-        if (!path7.startsWith("/amber-api/")) {
+      async amber(method, path23, body) {
+        if (!path23.startsWith("/amber-api/")) {
           throw new Error("Amber API path must start with '/amber-api/'.");
         }
-        return this.gateway(method, path7, body);
+        return this.gateway(method, path23, body);
       }
-      async market(method, path7, body) {
-        const url = new URL(path7, this.config.marketBaseUrl);
+      async market(method, path23, body) {
+        const url = new URL(path23, this.config.marketBaseUrl);
         const raw = await this.fetch(url.toString(), {
           method,
           headers: { "Content-Type": "application/json" },
@@ -4612,28 +4481,43 @@ 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, ASSET_CACHE_FILE, AssetCache;
+function typeStoredChains(stored, chainOf2, withChain) {
+  const records = [];
+  const invalid = [];
+  for (const record2 of stored) {
+    try {
+      records.push(withChain(record2, resolveChain(chainOf2(record2))));
+    } catch (err) {
+      invalid.push({ id: record2.id, chain: chainOf2(record2), error: errorMessage(err) });
+    }
+  }
+  return { records, invalid };
+}
+var fs, path2, crypto2, crypto22, path22, 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";
     fs = __toESM(require("fs"), 1);
-    path = __toESM(require("path"), 1);
-    os = __toESM(require("os"), 1);
+    path2 = __toESM(require("path"), 1);
     crypto2 = __toESM(require("crypto"), 1);
+    init_dist();
     crypto22 = __toESM(require("crypto"), 1);
+    path22 = __toESM(require("path"), 1);
     import_keyring = require("@napi-rs/keyring");
+    init_dist();
     crypto3 = __toESM(require("crypto"), 1);
+    init_dist();
     crypto4 = __toESM(require("crypto"), 1);
     FileStore = class {
       dataDir;
       constructor(config) {
-        this.dataDir = config?.dataDir || path.join(os.homedir(), ".twak");
+        this.dataDir = config?.dataDir || twakHome();
       }
       getDataDir() {
         return this.dataDir;
       }
       async read(filename) {
-        const filePath = path.join(this.dataDir, filename);
+        const filePath = path2.join(this.dataDir, filename);
         try {
           const data = await fs.promises.readFile(filePath, "utf-8");
           return JSON.parse(data);
@@ -4646,7 +4530,7 @@ var init_dist2 = __esm({
       }
       async write(filename, data) {
         await fs.promises.mkdir(this.dataDir, { recursive: true, mode: 448 });
-        const filePath = path.join(this.dataDir, filename);
+        const filePath = path2.join(this.dataDir, filename);
         const tmpPath = `${filePath}.tmp.${crypto2.randomBytes(8).toString("hex")}`;
         await fs.promises.writeFile(tmpPath, JSON.stringify(data, null, 2), {
           encoding: "utf-8",
@@ -4663,7 +4547,7 @@ var init_dist2 = __esm({
         }
       }
       async exists(filename) {
-        const filePath = path.join(this.dataDir, filename);
+        const filePath = path2.join(this.dataDir, filename);
         try {
           await fs.promises.access(filePath);
           return true;
@@ -4672,7 +4556,7 @@ var init_dist2 = __esm({
         }
       }
       async remove(filename) {
-        const filePath = path.join(this.dataDir, filename);
+        const filePath = path2.join(this.dataDir, filename);
         try {
           await fs.promises.unlink(filePath);
         } catch {
@@ -4689,24 +4573,33 @@ var init_dist2 = __esm({
     API_SECRET_ACCOUNT = "api-secret";
     PROBE_ACCOUNT = "probe";
     KeychainManager = class {
+      walletAccount;
+      apiSecretAccount;
+      /** `dataDir`: the twak folder these secrets belong to (default: twakHome()). */
+      constructor(dataDir = twakHome()) {
+        const folder = path22.resolve(dataDir);
+        const suffix = folder === twakHome({}) ? "" : `@${folder}`;
+        this.walletAccount = WALLET_ACCOUNT + suffix;
+        this.apiSecretAccount = API_SECRET_ACCOUNT + suffix;
+      }
       async getWalletPassword() {
-        return getPassword(SERVICE, WALLET_ACCOUNT);
+        return getPassword(SERVICE, this.walletAccount);
       }
       async saveWalletPassword(password3) {
-        new import_keyring.Entry(SERVICE, WALLET_ACCOUNT).setPassword(password3);
+        new import_keyring.Entry(SERVICE, this.walletAccount).setPassword(password3);
       }
       async deleteWalletPassword() {
-        new import_keyring.Entry(SERVICE, WALLET_ACCOUNT).deletePassword();
+        new import_keyring.Entry(SERVICE, this.walletAccount).deletePassword();
       }
       async getApiSecret() {
-        return getPassword(SERVICE, API_SECRET_ACCOUNT);
+        return getPassword(SERVICE, this.apiSecretAccount);
       }
       async saveApiSecret(secret) {
-        new import_keyring.Entry(SERVICE, API_SECRET_ACCOUNT).setPassword(secret);
+        new import_keyring.Entry(SERVICE, this.apiSecretAccount).setPassword(secret);
       }
       async deleteApiSecret() {
         try {
-          new import_keyring.Entry(SERVICE, API_SECRET_ACCOUNT).deletePassword();
+          new import_keyring.Entry(SERVICE, this.apiSecretAccount).deletePassword();
         } catch {
         }
       }
@@ -4742,7 +4635,7 @@ var init_dist2 = __esm({
       kc;
       constructor(config) {
         this.store = new FileStore(config);
-        this.kc = new KeychainManager();
+        this.kc = new KeychainManager(this.store.getDataDir());
       }
       async load() {
         const stored = await this.store.read(CREDENTIALS_FILE);
@@ -4826,8 +4719,18 @@ var init_dist2 = __esm({
       constructor(config) {
         this.store = new FileStore(config);
       }
+      async readStored() {
+        return await this.store.read(ALERTS_FILE) || [];
+      }
+      typed(stored) {
+        return typeStoredChains(
+          stored,
+          (a3) => a3.chainKey,
+          (a3, chainKey) => ({ ...a3, chainKey })
+        );
+      }
       async create(alert) {
-        const alerts = await this.list();
+        const alerts = await this.readStored();
         const record2 = {
           ...alert,
           id: crypto3.randomUUID(),
@@ -4838,23 +4741,28 @@ var init_dist2 = __esm({
         await this.store.write(ALERTS_FILE, alerts);
         return record2;
       }
+      /** Alerts whose chain resolves; see listInvalid for the others. */
       async list() {
-        return await this.store.read(ALERTS_FILE) || [];
+        return this.typed(await this.readStored()).records;
+      }
+      /** Stored alerts whose chain no longer resolves. */
+      async listInvalid() {
+        return this.typed(await this.readStored()).invalid;
       }
       async getById(id) {
         const alerts = await this.list();
         return alerts.find((a3) => a3.id === id);
       }
       async update(id, updates) {
-        const alerts = await this.list();
+        const alerts = await this.readStored();
         const index = alerts.findIndex((a3) => a3.id === id);
         if (index === -1) return void 0;
         alerts[index] = { ...alerts[index], ...updates };
         await this.store.write(ALERTS_FILE, alerts);
-        return alerts[index];
+        return this.typed([alerts[index]]).records[0];
       }
       async delete(id) {
-        const alerts = await this.list();
+        const alerts = await this.readStored();
         const filtered = alerts.filter((a3) => a3.id !== id);
         if (filtered.length === alerts.length) return false;
         await this.store.write(ALERTS_FILE, filtered);
@@ -4874,8 +4782,18 @@ var init_dist2 = __esm({
       constructor(config) {
         this.store = new FileStore(config);
       }
+      async readStored() {
+        return await this.store.read(AUTOMATIONS_FILE) || [];
+      }
+      typed(stored) {
+        return typeStoredChains(
+          stored,
+          (a3) => a3.chain,
+          (a3, chain2) => ({ ...a3, chain: chain2 })
+        );
+      }
       async create(record2) {
-        const automations = await this.list();
+        const automations = await this.readStored();
         const entry = {
           ...record2,
           id: crypto4.randomUUID(),
@@ -4886,23 +4804,28 @@ var init_dist2 = __esm({
         await this.store.write(AUTOMATIONS_FILE, automations);
         return entry;
       }
+      /** Automations whose chain resolves; see listInvalid for the others. */
       async list() {
-        return await this.store.read(AUTOMATIONS_FILE) || [];
+        return this.typed(await this.readStored()).records;
+      }
+      /** Stored automations whose chain no longer resolves. */
+      async listInvalid() {
+        return this.typed(await this.readStored()).invalid;
       }
       async getById(id) {
         const automations = await this.list();
         return automations.find((a3) => a3.id === id);
       }
       async update(id, updates) {
-        const automations = await this.list();
+        const automations = await this.readStored();
         const index = automations.findIndex((a3) => a3.id === id);
         if (index === -1) return void 0;
         automations[index] = { ...automations[index], ...updates };
         await this.store.write(AUTOMATIONS_FILE, automations);
-        return automations[index];
+        return this.typed([automations[index]]).records[0];
       }
       async delete(id) {
-        const automations = await this.list();
+        const automations = await this.readStored();
         const filtered = automations.filter((a3) => a3.id !== id);
         if (filtered.length === automations.length) return false;
         await this.store.write(AUTOMATIONS_FILE, filtered);
@@ -5827,15 +5750,15 @@ var require_route = __commonJS({
       };
     }
     function wrapConversion(toModel, graph) {
-      const path7 = [graph[toModel].parent, toModel];
+      const path13 = [graph[toModel].parent, toModel];
       let fn2 = conversions[graph[toModel].parent][toModel];
       let cur = graph[toModel].parent;
       while (graph[cur].parent) {
-        path7.unshift(graph[cur].parent);
+        path13.unshift(graph[cur].parent);
         fn2 = link(conversions[graph[cur].parent][cur], fn2);
         cur = graph[cur].parent;
       }
-      fn2.conversion = path7;
+      fn2.conversion = path13;
       return fn2;
     }
     module2.exports = function(fromModel) {
@@ -6076,7 +5999,7 @@ var require_has_flag = __commonJS({
 var require_supports_color = __commonJS({
   "../../node_modules/.pnpm/supports-color@7.2.0/node_modules/supports-color/index.js"(exports2, module2) {
     "use strict";
-    var os5 = require("os");
+    var os4 = require("os");
     var tty = require("tty");
     var hasFlag = require_has_flag();
     var { env } = process;
@@ -6124,7 +6047,7 @@ var require_supports_color = __commonJS({
         return min;
       }
       if (process.platform === "win32") {
-        const osRelease = os5.release().split(".");
+        const osRelease = os4.release().split(".");
         if (Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
           return Number(osRelease[2]) >= 14931 ? 3 : 2;
         }
@@ -6506,8 +6429,8 @@ var require_source = __commonJS({
 });
 
 // ../wallet-core/dist/index.mjs
-var dist_exports2 = {};
-__export(dist_exports2, {
+var dist_exports = {};
+__export(dist_exports, {
   AgentWalletProvider: () => AgentWalletProvider,
   ChainClient: () => ChainClient,
   TeeWalletProvider: () => TeeWalletProvider,
@@ -6545,13 +6468,13 @@ function getPolyfillNaasSessionId() {
 }
 function resolveSdkDir() {
   try {
-    return path2.dirname(__require.resolve("@trustwallet-trust-sdk/trust-sdk"));
+    return path3.dirname(__require.resolve("@trustwallet-trust-sdk/trust-sdk"));
   } catch {
     let dir = __dirname;
     for (let i2 = 0; i2 < 10; i2++) {
-      const candidate = path2.join(dir, "trust-sdk", "trust-sdk.js");
-      if (fs2.existsSync(candidate)) return path2.dirname(candidate);
-      const parent = path2.dirname(dir);
+      const candidate = path3.join(dir, "trust-sdk", "trust-sdk.js");
+      if (fs2.existsSync(candidate)) return path3.dirname(candidate);
+      const parent = path3.dirname(dir);
       if (parent === dir) break;
       dir = parent;
     }
@@ -6677,15 +6600,15 @@ function applyPolyfills() {
           }
         }
         if (!fs2.existsSync(filePath)) {
-          const basename2 = path2.basename(filePath);
-          const candidate = path2.join(sdkDir, basename2);
+          const basename2 = path3.basename(filePath);
+          const candidate = path3.join(sdkDir, basename2);
           if (fs2.existsSync(candidate)) {
             filePath = candidate;
           }
         }
-        const resolvedPath = path2.resolve(filePath);
-        const resolvedSdkDir = path2.resolve(sdkDir);
-        if (!resolvedPath.startsWith(resolvedSdkDir + path2.sep) && resolvedPath !== resolvedSdkDir) {
+        const resolvedPath = path3.resolve(filePath);
+        const resolvedSdkDir = path3.resolve(sdkDir);
+        if (!resolvedPath.startsWith(resolvedSdkDir + path3.sep) && resolvedPath !== resolvedSdkDir) {
           this.status = 403;
           if (this._async && this.onerror) this.onerror();
           return;
@@ -6710,8 +6633,7 @@ function applyPolyfills() {
     };
   }
   if (typeof globalThis.localStorage === "undefined") {
-    const os5 = __require("os");
-    const storePath = path2.join(os5.homedir(), ".twak", "local-storage.json");
+    const storePath = path3.join(twakHome(), "local-storage.json");
     const load = () => {
       try {
         return JSON.parse(fs2.readFileSync(storePath, "utf-8"));
@@ -6720,7 +6642,7 @@ function applyPolyfills() {
       }
     };
     const save = (data) => {
-      const dir = path2.dirname(storePath);
+      const dir = path3.dirname(storePath);
       if (!fs2.existsSync(dir)) fs2.mkdirSync(dir, { recursive: true, mode: 448 });
       const tmp = `${storePath}.tmp`;
       fs2.writeFileSync(tmp, JSON.stringify(data), { encoding: "utf-8", mode: 384 });
@@ -6993,7 +6915,7 @@ async function initTrustSDK(config) {
   await import_trust_sdk.AmberService.setEnvironment(import_trust_sdk.TwEnvironmentProduction);
   await import_trust_sdk.BlockchainService.useBitcoinV2();
   buildCoinTypeMap();
-  for (const cfg of Object.values(TESTNET_CHAINS)) {
+  for (const cfg of testnetChainKeys().map(chainOf)) {
     try {
       await import_trust_sdk.BlockchainService.setNode(
         new import_trust_sdk.CustomChain(getCoinType(cfg.coinId), cfg.chainId),
@@ -7120,25 +7042,15 @@ function decodeEvmTxFields(rawTxHex) {
   };
 }
 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);
+  const chainConfig = chainOf(chainKey);
+  const ct5 = getCoinType(chainConfig.coinId);
   if (!ct5) {
-    throw new TwakValidationError(`No CoinType mapping for coinId ${coinId}`, { chainKey, coinId });
-  }
-  const chainConfig = getChainById(canonicalKey);
-  if (!chainConfig) {
-    throw new TwakValidationError(`No chain config for ${canonicalKey}`, { chainKey });
+    throw new TwakValidationError(`No CoinType mapping for coinId ${chainConfig.coinId}`, {
+      chainKey,
+      coinId: chainConfig.coinId
+    });
   }
-  const chain2 = isTestnetChain(canonicalKey) ? new import_trust_sdk3.CustomChain(ct5, chainConfig.chainId) : new import_trust_sdk3.DefinedChain(ct5);
+  const chain2 = isTestnet(chainKey) ? new import_trust_sdk3.CustomChain(ct5, chainConfig.chainId) : new import_trust_sdk3.DefinedChain(ct5);
   return { chain: chain2, chainConfig };
 }
 function humanAmountToWei(amount, decimals = 18) {
@@ -7196,8 +7108,8 @@ function getCoinDecimals(coinId) {
     const ct5 = requireCoinType(coinId);
     return wc3.CoinTypeConfiguration.getDecimals(ct5);
   } catch {
-    const chain2 = getChainByCoinId(coinId);
-    return chain2?.decimals ?? 18;
+    const chainKey = mainnetChainKeyForCoinId(coinId);
+    return chainKey ? chainOf(chainKey).decimals : 18;
   }
 }
 function tokenTypeForCoinId(coinId) {
@@ -7278,9 +7190,9 @@ async function getAmberDomainsByCoinId() {
   }
   return domainsByCoinId;
 }
-async function gatewayFetch(method, path22, config, body) {
-  const headers = signRequest(method, path22, "", config.accessId, config.hmacSecret);
-  return fetch(`${GATEWAY_URL}${path22}`, {
+async function gatewayFetch(method, path23, config, body) {
+  const headers = signRequest(method, path23, "", config.accessId, config.hmacSecret);
+  return fetch(`${GATEWAY_URL}${path23}`, {
     method,
     headers: {
       ...headers,
@@ -7369,12 +7281,13 @@ function registerShutdownHandlers(providers, onBeforeExit) {
     process.removeListener("SIGTERM", handler);
   };
 }
-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, sponsorNonceByAddress, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, BSC_COIN_ID, DEFAULT_BSC_SPONSORED_RPC, SPONSOR_PRECHECK_TIMEOUT_MS, SPONSOR_USER_AGENT, RPC_TIMEOUT_MS, RECEIPT_POLL_INTERVAL_MS, RECEIPT_DEFAULT_TIMEOUT_MS, ChainClient, SigningChainClient, 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 fs2, path3, import_trust_sdk, import_trust_sdk2, import_trust_sdk3, import_trust_sdk4, import_trust_sdk5, import_crypto2, __require, polyfillsApplied, _credentials, _naasSessionId, nodeStubsPatched, sponsorNonceByAddress, NAAS_SESSION_RE, naasSessionPatched, coinTypeByValue, walletCore, initialized, BSC_COIN_ID, DEFAULT_BSC_SPONSORED_RPC, SPONSOR_PRECHECK_TIMEOUT_MS, SPONSOR_USER_AGENT, RPC_TIMEOUT_MS, RECEIPT_POLL_INTERVAL_MS, RECEIPT_DEFAULT_TIMEOUT_MS, ChainClient, SigningChainClient, WalletCoreSigner, domainsByCoinId, GATEWAY_URL, DEVICE_INFO_BODY, VerifyCredentialsError, WALLET_ID_SUFFIX, WALLET_ID_LENGTH, EVM_COIN_IDS, MAINTAINED_COIN_IDS, WalletProvider, AgentWalletProvider, ETHEREUM, TeeWalletProvider, WalletContext, SHUTDOWN_TIMEOUT_MS;
 var init_dist3 = __esm({
   "../wallet-core/dist/index.mjs"() {
     "use strict";
     fs2 = __toESM(require("fs"), 1);
-    path2 = __toESM(require("path"), 1);
+    path3 = __toESM(require("path"), 1);
+    init_dist();
     import_trust_sdk = require("@trustwallet-trust-sdk/trust-sdk");
     init_dist();
     import_trust_sdk2 = require("@trustwallet-trust-sdk/trust-sdk");
@@ -7389,6 +7302,7 @@ var init_dist3 = __esm({
     init_dist();
     init_dist2();
     init_dist();
+    init_dist();
     __require = /* @__PURE__ */ ((x6) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x6, {
       get: (a3, b3) => (typeof require !== "undefined" ? require : a3)[b3]
     }) : x6)(function(x6) {
@@ -7571,7 +7485,7 @@ var init_dist3 = __esm({
             if (!isTransientRateLimit(err) || Date.now() + pollMs >= deadline) throw err;
           }
           const sleepMs = Math.min(pollMs, Math.max(0, deadline - Date.now()));
-          await new Promise((resolve2) => setTimeout(resolve2, sleepMs));
+          await new Promise((resolve22) => setTimeout(resolve22, sleepMs));
         }
         throw new TwakNetworkError(`Timed out waiting for receipt ${hash} on ${chainKey}`, {
           hash,
@@ -7582,9 +7496,7 @@ var init_dist3 = __esm({
         return def.using(this);
       }
       async findTransactionStatus(chainKey, address, hash) {
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) throw new Error(`Unsupported chain: ${chainKey}`);
-        const account = this.createAccountForAddress(coinId, address);
+        const account = this.createAccountForAddress(coinIdOf(chainKey), address, chainKey);
         let result;
         try {
           result = await import_trust_sdk2.BlockchainService.findTransaction(account, hash);
@@ -7604,27 +7516,17 @@ var init_dist3 = __esm({
         };
       }
       async getNodes(chainKey) {
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
-        const ct5 = requireCoinType(coinId);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
+        const { chain: chain2 } = chainKeyToDefinedChain(chainKey);
         const nodes = await import_trust_sdk2.BlockchainService.getNodes(chain2);
         return nodes.map((n4) => ({ url: n4.url }));
       }
       async setNode(chainKey, rpcUrl) {
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
-        const ct5 = requireCoinType(coinId);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
+        const { chain: chain2 } = chainKeyToDefinedChain(chainKey);
         await import_trust_sdk2.BlockchainService.setNode(chain2, new import_trust_sdk2.Node(rpcUrl));
       }
       createAccountForAddress(coinId, address, chainKey) {
         const ct5 = requireCoinType(coinId);
-        const chain2 = chainKey !== void 0 && isTestnetChain(chainKey) ? chainKeyToDefinedChain(chainKey).chain : new import_trust_sdk2.DefinedChain(ct5);
+        const chain2 = chainKey !== void 0 && isTestnet(chainKey) ? chainKeyToDefinedChain(chainKey).chain : new import_trust_sdk2.DefinedChain(ct5);
         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);
@@ -7753,9 +7655,9 @@ var init_dist3 = __esm({
         return this.signAndBroadcast(transaction, account, coinId, chainKey, ct5, params.hdWallet);
       }
       async transferRawSolana(params) {
-        const ct5 = requireCoinType(501);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
-        const account = this.getAccountFromSigner("solana");
+        const { chain: chain2 } = chainKeyToDefinedChain(params.chainKey);
+        const ct5 = requireCoinType(coinIdOf(params.chainKey));
+        const account = this.getAccountFromSigner(params.chainKey);
         const asset = new import_trust_sdk2.Asset.Coin(account);
         const trade = new import_trust_sdk2.TransactionTrade(
           asset,
@@ -7774,24 +7676,16 @@ var init_dist3 = __esm({
         const nonce = await import_trust_sdk2.BlockchainService.fetchNonce(account);
         const encodedTx = await signTransactionBytes(trade, fee, nonce, params.hdWallet, ct5);
         const hash = await import_trust_sdk2.BlockchainService.sendTransactionV2(chain2, encodedTx);
-        return createPendingTransaction(this, "solana", hash);
+        return createPendingTransaction(this, params.chainKey, hash);
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       async signMessage(chainKey, message, privateKey) {
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
-        const ct5 = requireCoinType(coinId);
-        const payload = getChainById(chainKey)?.isEVM ? `0x${Buffer.from(message, "utf8").toString("hex")}` : message;
+        const ct5 = requireCoinType(coinIdOf(chainKey));
+        const payload = chainOf(chainKey).isEVM ? `0x${Buffer.from(message, "utf8").toString("hex")}` : message;
         return import_trust_sdk2.BlockchainService.signMessage(ct5, payload, import_trust_sdk2.MessageType.Message, privateKey);
       }
       async signTypedData(params) {
-        const coinId = chainKeyToCoinType(params.chainKey);
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${params.chainKey}`);
-        }
-        const ct5 = requireCoinType(coinId);
+        const ct5 = requireCoinType(coinIdOf(params.chainKey));
         const privateKey = params.hdWallet.getKeyForCoin(ct5);
         if (!privateKey) {
           throw new Error(`Could not derive private key for chain ${params.chainKey}`);
@@ -7802,7 +7696,7 @@ var init_dist3 = __esm({
             params.typedDataJson,
             import_trust_sdk2.MessageType.TypedMessageEip155,
             privateKey,
-            params.chainId
+            evmChainIdOf(params.chainKey)
           );
         } finally {
           try {
@@ -7813,12 +7707,9 @@ var init_dist3 = __esm({
       }
       async estimateFee(assetId, params) {
         const { coinId, contractAddress } = parseTokenId(assetId);
-        const chainKey = coinTypeToChainKey(coinId);
-        if (!chainKey) {
-          throw new Error(`Unsupported coin type: ${coinId}`);
-        }
-        const ct5 = requireCoinType(coinId);
-        const chain2 = new import_trust_sdk2.DefinedChain(ct5);
+        const { chainKey } = params;
+        requireCoinType(coinId);
+        const { chain: chain2 } = chainKeyToDefinedChain(chainKey);
         const account = this.getAccountFromSigner(chainKey);
         const asset = contractAddress ? new import_trust_sdk2.Asset.Token(account, contractAddress, tokenTypeForCoinId(coinId)) : new import_trust_sdk2.Asset.Coin(account);
         const transaction = new import_trust_sdk2.TransactionTransfer(
@@ -7916,7 +7807,7 @@ var init_dist3 = __esm({
        * EIP-7702 token-as-gas sponsorship.
        */
       async signAndBroadcast(transaction, account, coinId, chainKey, ct5, hdWallet) {
-        const testnet = isTestnetChain(chainKey);
+        const testnet = isTestnet(chainKey);
         const chain2 = testnet ? chainKeyToDefinedChain(chainKey).chain : new import_trust_sdk2.DefinedChain(ct5);
         const sponsoredUrl = this.getSponsoredRpcUrl(coinId, testnet);
         if (sponsoredUrl) {
@@ -8023,7 +7914,7 @@ var init_dist3 = __esm({
        * Trust SDK routes through the Smart Wallet fee service internally.
        */
       async calculateFeeWithSponsorship(transaction, account, coinId, chainKey) {
-        if (!_SigningChainClient.SPONSORABLE_COINS.includes(coinId) || chainKey !== void 0 && isTestnetChain(chainKey)) {
+        if (!_SigningChainClient.SPONSORABLE_COINS.includes(coinId) || chainKey !== void 0 && isTestnet(chainKey)) {
           return { fee: await import_trust_sdk2.BlockchainService.calculateFee(transaction) };
         }
         let supports7702 = false;
@@ -8181,10 +8072,7 @@ var init_dist3 = __esm({
       getAddress(chainKey) {
         const cached = this.addressCache.get(chainKey);
         if (cached) return cached;
-        const coinId = chainKeyToCoinType(chainKey) ?? getChainById(chainKey)?.coinId;
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
+        const coinId = coinIdOf(chainKey);
         const ct5 = getCoinType(coinId);
         if (!ct5) {
           throw new Error(`No CoinType mapping for chain: ${chainKey} (coinId: ${coinId})`);
@@ -8201,16 +8089,13 @@ var init_dist3 = __esm({
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       getAccount(chainKey) {
-        const testnet = isTestnetChain(chainKey);
-        const coinId = chainKeyToCoinType(chainKey) ?? getChainById(chainKey)?.coinId;
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
+        const testnet = isTestnet(chainKey);
+        const coinId = coinIdOf(chainKey);
         const ct5 = getCoinType(coinId);
         if (!ct5) {
           throw new Error(`No CoinType mapping for chain: ${chainKey} (coinId: ${coinId})`);
         }
-        const chain2 = testnet ? new import_trust_sdk4.CustomChain(ct5, getChainById(chainKey).chainId) : new import_trust_sdk4.DefinedChain(ct5);
+        const chain2 = testnet ? new import_trust_sdk4.CustomChain(ct5, chainOf(chainKey).chainId) : 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}`);
@@ -8228,26 +8113,23 @@ var init_dist3 = __esm({
       }
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       getPrivateKey(chainKey) {
-        const coinId = chainKeyToCoinType(chainKey);
-        if (coinId === void 0) {
-          throw new Error(`Unsupported chain: ${chainKey}`);
-        }
+        const coinId = coinIdOf(chainKey);
         const ct5 = getCoinType(coinId);
         if (!ct5) {
           throw new Error(`No CoinType mapping for chain: ${chainKey} (coinId: ${coinId})`);
         }
         return this.hdWallet.getKeyForCoin(ct5);
       }
+      /** The wallet's address on every mainnet chain it supports, in registry order. */
       getAllAddresses() {
-        for (const chainKey of Object.keys(CHAINS)) {
-          if (!this.addressCache.has(chainKey)) {
-            try {
-              this.getAddress(chainKey);
-            } catch {
-            }
+        const addresses = /* @__PURE__ */ new Map();
+        for (const chainKey of mainnetChainKeys()) {
+          try {
+            addresses.set(chainKey, this.getAddress(chainKey));
+          } catch {
           }
         }
-        return new Map(this.addressCache);
+        return addresses;
       }
       destroy() {
         this.addressCache.clear();
@@ -8375,7 +8257,7 @@ var init_dist3 = __esm({
         const hdWallet = walletCore2.HDWallet.create(128, "");
         const mnemonic = hdWallet.mnemonic();
         const store = new WalletConfigStore();
-        await store.saveMnemonic(mnemonic, password3, Object.keys(CHAINS));
+        await store.saveMnemonic(mnemonic, password3, mainnetChainKeys());
         const signer = WalletCoreSigner.fromHDWallet(hdWallet);
         const client = new SigningChainClient(signer);
         return new _AgentWalletProvider(signer, client);
@@ -8389,32 +8271,32 @@ var init_dist3 = __esm({
       }
       static async fromMnemonic(mnemonic, password3) {
         const store = new WalletConfigStore();
-        await store.saveMnemonic(mnemonic, password3, Object.keys(CHAINS));
+        await store.saveMnemonic(mnemonic, password3, mainnetChainKeys());
         const signer = await WalletCoreSigner.fromMnemonic(mnemonic);
         const client = new SigningChainClient(signer);
         return new _AgentWalletProvider(signer, client);
       }
-      async getAddress(chainId) {
+      async getAddress(chainKey) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
-        return this.signer.getAddress(chainId);
+        return this.signer.getAddress(chainKey);
       }
       async getAddresses() {
         await this.ensureConnected();
         this.resetAutoLockTimer();
         const addresses = this.signer.getAllAddresses();
         const result = [];
-        for (const [chainId, address] of addresses) {
-          result.push({ address, chainId });
+        for (const [chainKey, address] of addresses) {
+          result.push({ address, chainKey });
         }
         return result;
       }
-      async signMessage(chainId, message) {
+      async signMessage(chainKey, message) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
-        const privateKey = this.signer.getPrivateKey(chainId);
+        const privateKey = this.signer.getPrivateKey(chainKey);
         try {
-          return await this.blockchainClient.signMessage(chainId, message, privateKey);
+          return await this.blockchainClient.signMessage(chainKey, message, privateKey);
         } finally {
           try {
             privateKey.data().fill(0);
@@ -8422,12 +8304,11 @@ var init_dist3 = __esm({
           }
         }
       }
-      async signTypedData(chainKey, chainId, typedDataJson) {
+      async signTypedData(chainKey, typedDataJson) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
         return this.blockchainClient.signTypedData({
           chainKey,
-          chainId,
           typedDataJson,
           hdWallet: this.signer.getHDWallet()
         });
@@ -8435,25 +8316,16 @@ var init_dist3 = __esm({
       async sendTransaction(params) {
         await this.ensureConnected();
         this.resetAutoLockTimer();
-        const { getChainByEvmId: getChainByEvmId2, chainKeyToCoinType: chainKeyToCoinType3, resolveChain: resolveChain2 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
-        let assetId;
-        if (params.chainId.startsWith("eip155:")) {
-          const chain2 = getChainByEvmId2(params.chainId.replace("eip155:", ""));
-          if (!chain2) throw new Error(`Unsupported chain: ${params.chainId}`);
-          assetId = `c${chain2.coinId}`;
-        } else if (params.chainId.startsWith("solana:")) {
-          assetId = "c501";
-        } else {
-          const coinId = chainKeyToCoinType3(params.chainId);
-          if (coinId === void 0) throw new Error(`Unsupported chain: ${params.chainId}`);
-          assetId = `c${coinId}`;
-        }
-        const chainKey = resolveChain2(params.chainId);
+        const { chainKey } = params;
+        const chain2 = chainOf(chainKey);
+        const assetId = assetIdOf(chainKey);
+        const isSolana = chain2.namespace === "solana";
         const hdWallet = this.signer.getHDWallet();
         const hasCalldata = params.data && params.data !== "0x" && params.data !== "0x0";
         const hasValue = params.value && params.value !== "0x0" && params.value !== "0x" && params.value !== "0";
-        if (params.chainId.startsWith("solana:") && hasCalldata) {
+        if (isSolana && hasCalldata) {
           const result2 = await this.blockchainClient.transferRawSolana({
+            chainKey,
             serializedMessage: params.data,
             hdWallet
           });
@@ -8493,9 +8365,6 @@ var init_dist3 = __esm({
         this.resetAutoLockTimer();
         return this.blockchainClient.getOwnBalance(assetId, chainKey);
       }
-      supportsChain(chainId) {
-        return isChainSupported(chainId);
-      }
       /**
        * No-op for agent wallets — they are always connected via local HD wallet.
        * WalletConnect-style connection URIs/QR codes do not apply.
@@ -8521,22 +8390,23 @@ var init_dist3 = __esm({
         return this.connected;
       }
     };
+    ETHEREUM = knownChainKey("ethereum");
     TeeWalletProvider = class extends WalletProvider {
       name = "tee";
       kind = "remote";
       address = null;
-      async getAddress(_chainId) {
+      async getAddress(_chainKey) {
         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" }];
+        return [{ address: this.address, chainKey: ETHEREUM }];
       }
-      async signMessage(_chainId, _message) {
+      async signMessage(_chainKey, _message) {
         throw new Error("TEE signing not yet implemented");
       }
-      async signTypedData(_chainKey, _chainId, _typedDataJson) {
+      async signTypedData(_chainKey, _typedDataJson) {
         throw new Error("TEE signing not yet implemented");
       }
       async sendTransaction(_params) {
@@ -8548,10 +8418,7 @@ var init_dist3 = __esm({
       async getBalance() {
         throw new Error("TEE balances not yet implemented");
       }
-      supportsChain(_chainId) {
-        return false;
-      }
-      async connect(_chains) {
+      async connect(_chainKeys) {
         throw new Error("TEE wallet connect not yet implemented");
       }
       async disconnect() {
@@ -8719,15 +8586,15 @@ var init_dist3 = __esm({
        * V1 does not restrict the peer wallet: any WC v2 client can pair. The
        * user's choice to scan the QR is the consent moment.
        */
-      async beginWalletConnect(chains) {
-        return this.enqueue(() => this.beginWalletConnectImpl(chains));
+      async beginWalletConnect(chainKeys) {
+        return this.enqueue(() => this.beginWalletConnectImpl(chainKeys));
       }
-      async beginWalletConnectImpl(chains) {
+      async beginWalletConnectImpl(chainKeys) {
         const wc3 = this.walletConnect();
         this._generation++;
         await this.disconnectWcIfAny();
         try {
-          this._pairing = await wc3.connect(chains);
+          this._pairing = await wc3.connect(chainKeys);
         } catch (err) {
           this._wallet = void 0;
           this._pairing = void 0;
@@ -8848,11 +8715,11 @@ function __metadata(metadataKey, metadataValue) {
 }
 function __awaiter(thisArg, _arguments, P5, generator) {
   function adopt(value) {
-    return value instanceof P5 ? value : new P5(function(resolve2) {
-      resolve2(value);
+    return value instanceof P5 ? value : new P5(function(resolve4) {
+      resolve4(value);
     });
   }
-  return new (P5 || (P5 = Promise))(function(resolve2, reject) {
+  return new (P5 || (P5 = Promise))(function(resolve4, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -8868,7 +8735,7 @@ function __awaiter(thisArg, _arguments, P5, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -9046,14 +8913,14 @@ function __asyncValues(o4) {
   }, i2);
   function verb(n4) {
     i2[n4] = o4[n4] && function(v5) {
-      return new Promise(function(resolve2, reject) {
-        v5 = o4[n4](v5), settle(resolve2, reject, v5.done, v5.value);
+      return new Promise(function(resolve4, reject) {
+        v5 = o4[n4](v5), settle(resolve4, reject, v5.done, v5.value);
       });
     };
   }
-  function settle(resolve2, reject, d3, v5) {
+  function settle(resolve4, reject, d3, v5) {
     Promise.resolve(v5).then(function(v6) {
-      resolve2({ value: v6, done: d3 });
+      resolve4({ value: v6, done: d3 });
     }, reject);
   }
 }
@@ -9122,9 +8989,9 @@ var require_delay = __commonJS({
     Object.defineProperty(exports2, "__esModule", { value: true });
     exports2.delay = void 0;
     function delay(timeout) {
-      return new Promise((resolve2) => {
+      return new Promise((resolve4) => {
         setTimeout(() => {
-          resolve2(true);
+          resolve4(true);
         }, timeout);
       });
     }
@@ -9390,9 +9257,9 @@ var require_cjs3 = __commonJS({
                   if (href.indexOf("/") === 0) {
                     absoluteHref += href;
                   } else {
-                    const path7 = loc.pathname.split("/");
-                    path7.pop();
-                    const finalPath = path7.join("/");
+                    const path13 = loc.pathname.split("/");
+                    path13.pop();
+                    const finalPath = path13.join("/");
                     absoluteHref += finalPath + "/" + href;
                   }
                   icons2.push(absoluteHref);
@@ -13448,8 +13315,8 @@ var require_ws = __commonJS({
 });
 
 // ../contracts/dist/index.mjs
-var dist_exports3 = {};
-__export(dist_exports3, {
+var dist_exports2 = {};
+__export(dist_exports2, {
   COMPETITION_ABI: () => COMPETITION_ABI,
   COMPETITION_ADDRESSES: () => COMPETITION_ADDRESSES,
   ERC20_ABI: () => ERC20_ABI,
@@ -14234,7 +14101,7 @@ function createContractInstance(opts) {
       address
     });
   }
-  const chainDef = requireChain(chainKey);
+  const chainDef = chainOf(chainKey);
   if (chainDef.namespace !== "eip155") {
     throw new TwakValidationError(
       `Contract calls are EVM-only; ${chainKey} is namespace ${chainDef.namespace}`,
@@ -14290,7 +14157,7 @@ function buildWriteProxy(abi, address, chainKey, client) {
         }
         const data = encodeFunctionCall(abi, prop, args);
         const hash = await signer.sendTransaction({
-          chainId: chainKeyToCaip2(chainKey),
+          chainKey,
           to: address,
           data,
           value: "0x0"
@@ -14365,10 +14232,6 @@ function hexToSafeNumber(hex2, fieldName) {
   }
   return Number(big);
 }
-function chainKeyToCaip2(chainKey) {
-  const def = requireChain(chainKey);
-  return `${def.namespace}:${def.chainId}`;
-}
 function isJsInternal(prop) {
   return JS_INTERNAL_PROPS.has(prop);
 }
@@ -14448,9 +14311,8 @@ function parseOptParams(value) {
 function jobStatusName(status) {
   return JOB_STATUS[Number(status)] ?? "Unknown";
 }
-function resolveErc8183Contracts(client, chainInput) {
-  const chainKey = resolveChain(chainInput);
-  const chain2 = requireChain(chainKey);
+function resolveErc8183Contracts(client, chainKey) {
+  const chain2 = chainOf(chainKey);
   if (chain2.namespace !== "eip155") {
     throw new WalletError(
       "CHAIN_UNSUPPORTED",
@@ -14470,9 +14332,8 @@ function resolveErc8183Contracts(client, chainInput) {
     chainKey
   };
 }
-function resolveErc8004Contract(client, chainInput) {
-  const chainKey = resolveChain(chainInput);
-  const chain2 = requireChain(chainKey);
+function resolveErc8004Contract(client, chainKey) {
+  const chain2 = chainOf(chainKey);
   if (chain2.namespace !== "eip155") {
     throw new WalletError(
       "CHAIN_UNSUPPORTED",
@@ -14490,7 +14351,7 @@ function resolveErc8004Contract(client, chainInput) {
   return { contract, chainKey };
 }
 function resolveCompetitionContract(client) {
-  const chainKey = "bsc";
+  const chainKey = knownChainKey("bsc");
   const addressOverride = process.env.COMPETITION_REGISTRY_ADDRESS;
   const contract = competition.using(client).resolve({ chainKey, addressOverride });
   return { contract, chainKey };
@@ -14510,6 +14371,7 @@ var init_dist4 = __esm({
     init_dist();
     init_dist();
     init_dist();
+    init_dist();
     HEX_PATTERN = /^0x[0-9a-fA-F]*$/;
     BRIDGE = {
       createAbiFunction(name2) {
@@ -15108,18 +14970,18 @@ var init_dist4 = __esm({
         anonymous: false
       }
     ];
-    ERC8183_COMMERCE_ADDRESSES = {
+    ERC8183_COMMERCE_ADDRESSES = byChainKey({
       bsc: "0xea4daa3100a767e86fded867729ae7446476eba6",
       bsctestnet: "0xa206c0517b6371c6638cd9e4a42cc9f02a33b0de"
-    };
-    ERC8183_ROUTER_ADDRESSES = {
+    });
+    ERC8183_ROUTER_ADDRESSES = byChainKey({
       bsc: "0x51895229e12f9876011789b04f8698af06ccd6da",
       bsctestnet: "0xd7d36d66d2f1b608a0f943f722d27e3744f66f25"
-    };
-    ERC8183_POLICY_ADDRESSES = {
+    });
+    ERC8183_POLICY_ADDRESSES = byChainKey({
       bsc: "0x9c01845705b3078aa2e8cff7520a6376fd766de5",
       bsctestnet: "0x4f4678d4439fec812ac7674bb3efb4c8f5fb78a6"
-    };
+    });
     erc8183Commerce = defineContract({
       id: "erc8183-commerce",
       abi: ERC8183_COMMERCE_ABI,
@@ -15561,10 +15423,10 @@ var init_dist4 = __esm({
         anonymous: false
       }
     ];
-    ERC8004_ADDRESSES = {
+    ERC8004_ADDRESSES = byChainKey({
       bsc: "0x8004a169fb4a3325136eb29fa0ceb6d2e539a432",
       bsctestnet: "0x8004a818bfb912233c491871b3d84c89a494bd9e"
-    };
+    });
     erc8004 = defineContract({
       id: "erc8004",
       abi: ERC8004_ABI,
@@ -15606,9 +15468,9 @@ var init_dist4 = __esm({
         anonymous: false
       }
     ];
-    COMPETITION_ADDRESSES = {
+    COMPETITION_ADDRESSES = byChainKey({
       bsc: "0x212c61B9B72C95d95BF29CF032F5E5635629Aed5"
-    };
+    });
     competition = defineContract({
       id: "competition",
       abi: COMPETITION_ABI,
@@ -16334,24 +16196,73 @@ var dapps_service_exports = {};
 __export(dapps_service_exports, {
   DappsService: () => DappsService
 });
-var fs7, path5, os3, CACHE_FILE, CACHE_TTL_MS, DappsService;
+function toProtocol(p3) {
+  const llamaChains = Array.isArray(p3.chains) ? p3.chains : [];
+  return {
+    id: p3.id || p3.slug || "",
+    name: p3.name || "",
+    symbol: p3.symbol || "",
+    url: p3.url || "",
+    description: p3.description || "",
+    category: p3.category || "",
+    chains: llamaChains.flatMap(
+      (c3) => typeof c3 === "string" && LLAMA_CHAIN_KEYS[c3] ? [LLAMA_CHAIN_KEYS[c3]] : []
+    ),
+    tvl: p3.tvl ?? 0,
+    logo: p3.logo || "",
+    audits: p3.audits || "0",
+    change1d: p3.change_1d ?? null,
+    change7d: p3.change_7d ?? null,
+    mcap: p3.mcap ?? null
+  };
+}
+var fs7, path11, cacheFile, CACHE_TTL_MS, CACHE_VERSION, LLAMA_CHAIN_KEYS, DappsService;
 var init_dapps_service = __esm({
   "../security/dist/services/dapps-service.mjs"() {
     "use strict";
     fs7 = __toESM(require("fs"), 1);
-    path5 = __toESM(require("path"), 1);
-    os3 = __toESM(require("os"), 1);
+    path11 = __toESM(require("path"), 1);
     init_dist();
-    CACHE_FILE = path5.join(os3.homedir(), ".twak", "dapps-cache.json");
+    cacheFile = () => path11.join(twakHome(), "dapps-cache.json");
     CACHE_TTL_MS = 6 * 36e5;
+    CACHE_VERSION = 2;
+    LLAMA_CHAIN_KEYS = Object.fromEntries(
+      Object.entries({
+        Ethereum: "ethereum",
+        Binance: "bsc",
+        Arbitrum: "arbitrum",
+        Base: "base",
+        Polygon: "polygon",
+        Avalanche: "avalanche",
+        Solana: "solana",
+        Optimism: "optimism",
+        Fantom: "fantom",
+        Sonic: "sonic",
+        Linea: "linea",
+        Bitcoin: "bitcoin",
+        Blast: "blast",
+        "zkSync Era": "zksync",
+        Scroll: "scroll",
+        Sui: "sui",
+        Tron: "tron",
+        TON: "ton",
+        Aptos: "aptos",
+        Celo: "celo",
+        Near: "near",
+        Litecoin: "litecoin",
+        Cosmos: "cosmos",
+        Aurora: "aurora",
+        Doge: "dogecoin"
+      }).map(([name2, key]) => [name2, knownChainKey(key)])
+    );
     DappsService = class {
       protocols = null;
       async getProtocols() {
         if (this.protocols) return this.protocols;
         const cached = this.readCache();
         if (cached) {
-          this.protocols = cached;
-          return cached;
+          this.protocols = cached.map(toProtocol);
+          return this.protocols;
         }
         let resp;
         try {
@@ -16364,23 +16275,9 @@ var init_dapps_service = __esm({
         if (!resp.ok) {
           throw new TwakApiError(`DeFi Llama API error: ${resp.status}`, resp.status);
         }
-        const raw = await resp.json();
-        this.protocols = raw.filter((p3) => p3.tvl > 0).map((p3) => ({
-          id: p3.id || p3.slug || "",
-          name: p3.name || "",
-          symbol: p3.symbol || "",
-          url: p3.url || "",
-          description: p3.description || "",
-          category: p3.category || "",
-          chains: Array.isArray(p3.chains) ? p3.chains : [],
-          tvl: p3.tvl ?? 0,
-          logo: p3.logo || "",
-          audits: p3.audits || "0",
-          change1d: p3.change_1d ?? null,
-          change7d: p3.change_7d ?? null,
-          mcap: p3.mcap ?? null
-        }));
-        this.writeCache(this.protocols);
+        const raw = (await resp.json()).filter((p3) => (p3.tvl ?? 0) > 0);
+        this.protocols = raw.map(toProtocol);
+        this.writeCache(raw);
         return this.protocols;
       }
       async getTop(limit = 20, category) {
@@ -16408,9 +16305,9 @@ var init_dapps_service = __esm({
       }
       readCache() {
         try {
-          const raw = fs7.readFileSync(CACHE_FILE, "utf-8");
+          const raw = fs7.readFileSync(cacheFile(), "utf-8");
           const data = JSON.parse(raw);
-          if (Date.now() - data.fetchedAt < CACHE_TTL_MS) {
+          if (data.version === CACHE_VERSION && Date.now() - data.fetchedAt < CACHE_TTL_MS) {
             return data.protocols;
           }
         } catch {
@@ -16419,10 +16316,10 @@ var init_dapps_service = __esm({
       }
       writeCache(protocols) {
         try {
-          const dir = path5.dirname(CACHE_FILE);
+          const dir = path11.dirname(cacheFile());
           fs7.mkdirSync(dir, { recursive: true });
-          const data = { fetchedAt: Date.now(), protocols };
-          fs7.writeFileSync(CACHE_FILE, JSON.stringify(data));
+          const data = { version: CACHE_VERSION, fetchedAt: Date.now(), protocols };
+          fs7.writeFileSync(cacheFile(), JSON.stringify(data));
         } catch {
         }
       }
@@ -19381,7 +19278,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve2.call(this, root, ref);
+      let _sch = resolve4.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a2 = root.localRefs) === null || _a2 === void 0 ? void 0 : _a2[ref];
         const { schemaId } = this.opts;
@@ -19408,7 +19305,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve2(root, ref) {
+    function resolve4(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -19623,8 +19520,8 @@ var require_utils2 = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path7) {
-      let input2 = path7;
+    function removeDotSegments(path13) {
+      let input2 = path13;
       const output2 = [];
       let nextSlash = -1;
       let len = 0;
@@ -19823,8 +19720,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path7, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path7 && path7 !== "/" ? path7 : void 0;
+        const [path13, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path13 && path13 !== "/" ? path13 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -19983,7 +19880,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve2(baseURI, relativeURI, options) {
+    function resolve4(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse(baseURI, schemelessOptions), parse(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -20210,7 +20107,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve2,
+      resolve: resolve4,
       resolveComponent,
       equal,
       serialize,
@@ -23222,11 +23119,11 @@ function __rest2(s2, e2) {
 }
 function __awaiter2(thisArg, _arguments, P5, generator) {
   function adopt(value) {
-    return value instanceof P5 ? value : new P5(function(resolve2) {
-      resolve2(value);
+    return value instanceof P5 ? value : new P5(function(resolve4) {
+      resolve4(value);
     });
   }
-  return new (P5 || (P5 = Promise))(function(resolve2, reject) {
+  return new (P5 || (P5 = Promise))(function(resolve4, reject) {
     function fulfilled(value) {
       try {
         step(generator.next(value));
@@ -23242,7 +23139,7 @@ function __awaiter2(thisArg, _arguments, P5, generator) {
       }
     }
     function step(result) {
-      result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
+      result.done ? resolve4(result.value) : adopt(result.value).then(fulfilled, rejected);
     }
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
@@ -23812,8 +23709,8 @@ var init_timeline = __esm({
       };
       Timeline2.prototype.push = function(event) {
         var _this = this;
-        return new Promise(function(resolve2) {
-          _this.queue.push([event, resolve2]);
+        return new Promise(function(resolve4) {
+          _this.queue.push([event, resolve4]);
           _this.scheduleApply(0);
         });
       };
@@ -23833,7 +23730,7 @@ var init_timeline = __esm({
       };
       Timeline2.prototype.apply = function(item) {
         return __awaiter2(this, void 0, void 0, function() {
-          var _a2, event, _b, resolve2, before, before_1, before_1_1, plugin, e2, e_1_1, enrichment, enrichment_1, enrichment_1_1, plugin, e2, e_2_1, destination, executeDestinations;
+          var _a2, event, _b, resolve4, before, before_1, before_1_1, plugin, e2, e_1_1, enrichment, enrichment_1, enrichment_1_1, plugin, e2, e_2_1, destination, executeDestinations;
           var e_1, _c2, e_2, _d;
           return __generator2(this, function(_e6) {
             switch (_e6.label) {
@@ -23845,7 +23742,7 @@ var init_timeline = __esm({
                   ];
                 }
                 _a2 = __read2(item, 1), event = _a2[0];
-                _b = __read2(item, 2), resolve2 = _b[1];
+                _b = __read2(item, 2), resolve4 = _b[1];
                 this.loggerProvider.log("Timeline.apply: Initial event", event);
                 before = this.plugins.filter(function(plugin2) {
                   return plugin2.type === "before";
@@ -23866,7 +23763,7 @@ var init_timeline = __esm({
                 e2 = _e6.sent();
                 if (e2 === null) {
                   this.loggerProvider.log("Timeline.apply: Event filtered out by before plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
-                  resolve2({ event, code: 0, message: "" });
+                  resolve4({ event, code: 0, message: "" });
                   return [
                     2
                     /*return*/
@@ -23915,7 +23812,7 @@ var init_timeline = __esm({
                 e2 = _e6.sent();
                 if (e2 === null) {
                   this.loggerProvider.log("Timeline.apply: Event filtered out by enrichment plugin '".concat(String(plugin.name), "', event: ").concat(JSON.stringify(event)));
-                  resolve2({ event, code: 0, message: "" });
+                  resolve4({ event, code: 0, message: "" });
                   return [
                     2
                     /*return*/
@@ -23958,7 +23855,7 @@ var init_timeline = __esm({
                 void Promise.all(executeDestinations).then(function(_a3) {
                   var _b2 = __read2(_a3, 1), result = _b2[0];
                   var resolveResult = result || buildResult(event, 100, "Event not tracked, no destination plugins on the instance");
-                  resolve2(resolveResult);
+                  resolve4(resolveResult);
                 });
                 return [
                   2
@@ -24297,8 +24194,8 @@ var init_core_client = __esm({
           var _this = this;
           return __generator2(this, function(_a2) {
             if (!this.isReady) {
-              return [2, new Promise(function(resolve2) {
-                _this.dispatchQ.push(_this.dispatchWithCallback.bind(_this, event, resolve2));
+              return [2, new Promise(function(resolve4) {
+                _this.dispatchQ.push(_this.dispatchWithCallback.bind(_this, event, resolve4));
               })];
             }
             return [2, this.process(event)];
@@ -24731,12 +24628,12 @@ var init_debug = __esm({
         };
       };
     };
-    getValueByStringPath = function(obj, path7) {
+    getValueByStringPath = function(obj, path13) {
       var e_1, _a2;
-      path7 = path7.replace(/\[(\w+)\]/g, ".$1");
-      path7 = path7.replace(/^\./, "");
+      path13 = path13.replace(/\[(\w+)\]/g, ".$1");
+      path13 = path13.replace(/^\./, "");
       try {
-        for (var _b = __values2(path7.split(".")), _c2 = _b.next(); !_c2.done; _c2 = _b.next()) {
+        for (var _b = __values2(path13.split(".")), _c2 = _b.next(); !_c2.done; _c2 = _b.next()) {
           var attr = _c2.value;
           if (attr in obj) {
             obj = obj[attr];
@@ -24761,8 +24658,8 @@ var init_debug = __esm({
         var res = {};
         try {
           for (var paths_1 = __values2(paths), paths_1_1 = paths_1.next(); !paths_1_1.done; paths_1_1 = paths_1.next()) {
-            var path7 = paths_1_1.value;
-            res[path7] = getValueByStringPath(client, path7);
+            var path13 = paths_1_1.value;
+            res[path13] = getValueByStringPath(client, path13);
           }
         } catch (e_2_1) {
           e_2 = { error: e_2_1 };
@@ -24900,12 +24797,12 @@ var init_destination = __esm({
         if (!event.insert_id) {
           event.insert_id = UUID();
         }
-        return new Promise(function(resolve2) {
+        return new Promise(function(resolve4) {
           var context = {
             event,
             attempts: 0,
             callback: function(result) {
-              return resolve2(result);
+              return resolve4(result);
             },
             timeout: 0
           };
@@ -25417,7 +25314,7 @@ var init_context = __esm({
       };
       Context2.prototype.execute = function(context) {
         var _this = this;
-        return new Promise(function(resolve2) {
+        return new Promise(function(resolve4) {
           var time = (/* @__PURE__ */ new Date()).getTime();
           var contextEvent = __assign2(__assign2(__assign2({ time, insert_id: UUID(), plan: _this.config.plan }, _this.config.ingestionMetadata && {
             ingestion_metadata: {
@@ -25425,7 +25322,7 @@ var init_context = __esm({
               source_version: _this.config.ingestionMetadata.sourceVersion
             }
           }), context), { event_id: _this.eventId++, library: _this.library });
-          return resolve2(contextEvent);
+          return resolve4(contextEvent);
         });
       };
       return Context2;
@@ -25471,7 +25368,7 @@ var init_http = __esm({
           port: url.port,
           protocol: url.protocol
         };
-        return new Promise(function(resolve2) {
+        return new Promise(function(resolve4) {
           var req = protocol.request(options, function(res) {
             res.setEncoding("utf8");
             var responsePayload = "";
@@ -25483,15 +25380,15 @@ var init_http = __esm({
                 try {
                   var parsedResponsePayload = JSON.parse(responsePayload);
                   var result = _this.buildResponse(parsedResponsePayload);
-                  resolve2(result);
+                  resolve4(result);
                 } catch (_a2) {
-                  resolve2(_this.buildResponse({ code: res.statusCode }));
+                  resolve4(_this.buildResponse({ code: res.statusCode }));
                 }
               }
             });
           });
           req.on("error", function() {
-            return resolve2(null);
+            return resolve4(null);
           });
           req.end(requestPayload);
         });
@@ -25677,6 +25574,7 @@ var {
 } = import_index.default;
 
 // src/commands/init.ts
+var path5 = __toESM(require("path"));
 init_dist();
 init_dist2();
 
@@ -25798,12 +25696,10 @@ async function ensureTrustSDK() {
 }
 async function registerWalletWithBackend(creds, provider) {
   const accounts = [];
-  for (const key of Object.keys(CHAINS)) {
-    const chain2 = getChainById(key);
-    if (!chain2) continue;
+  for (const key of mainnetChainKeys()) {
     try {
       const address = await provider.getAddress(key);
-      if (address) accounts.push({ coin: chain2.coinId, address });
+      if (address) accounts.push({ coin: coinIdOf(key), address });
     } catch {
     }
   }
@@ -25811,6 +25707,11 @@ async function registerWalletWithBackend(creds, provider) {
     await registerDeviceAndWallet(creds, accounts);
   }
 }
+async function findWalletPassword(opts) {
+  if (opts?.password) return opts.password;
+  if (process.env.TWAK_WALLET_PASSWORD) return process.env.TWAK_WALLET_PASSWORD;
+  return new KeychainManager().getWalletPassword();
+}
 async function resolvePassword(opts) {
   if (opts?.password) {
     process.stderr.write(
@@ -25818,12 +25719,9 @@ async function resolvePassword(opts) {
         "Note: --password is visible in shell history. Use `twak wallet keychain save` or TWAK_WALLET_PASSWORD instead.\n"
       )
     );
-    return opts.password;
   }
-  if (process.env.TWAK_WALLET_PASSWORD) return process.env.TWAK_WALLET_PASSWORD;
-  const kc2 = new KeychainManager();
-  const stored = await kc2.getWalletPassword();
-  if (stored) return stored;
+  const password3 = await findWalletPassword(opts);
+  if (password3) return password3;
   throw new Error(
     "No wallet password found. Provide --password, set TWAK_WALLET_PASSWORD, or run `twak wallet keychain save --password <pw>`"
   );
@@ -26496,8 +26394,8 @@ async function dispose(driver) {
 
 // ../../node_modules/.pnpm/idb-keyval@6.2.2/node_modules/idb-keyval/dist/index.js
 function promisifyRequest(request) {
-  return new Promise((resolve2, reject) => {
-    request.oncomplete = request.onsuccess = () => resolve2(request.result);
+  return new Promise((resolve4, reject) => {
+    request.oncomplete = request.onsuccess = () => resolve4(request.result);
     request.onabort = request.onerror = () => reject(request.error);
   });
 }
@@ -28351,10 +28249,10 @@ var __spreadArray = function(to3, from8, pack) {
 var BrowserInfo = (
   /** @class */
   /* @__PURE__ */ (function() {
-    function BrowserInfo2(name2, version3, os5) {
+    function BrowserInfo2(name2, version3, os4) {
       this.name = name2;
       this.version = version3;
-      this.os = os5;
+      this.os = os4;
       this.type = "browser";
     }
     return BrowserInfo2;
@@ -28375,10 +28273,10 @@ var NodeInfo = (
 var SearchBotDeviceInfo = (
   /** @class */
   /* @__PURE__ */ (function() {
-    function SearchBotDeviceInfo2(name2, version3, os5, bot) {
+    function SearchBotDeviceInfo2(name2, version3, os4, bot) {
       this.name = name2;
       this.version = version3;
-      this.os = os5;
+      this.os = os4;
       this.bot = bot;
       this.type = "bot-device";
     }
@@ -28521,19 +28419,19 @@ function parseUserAgent(ua) {
     versionParts = [];
   }
   var version3 = versionParts.join(".");
-  var os5 = detectOS(ua);
+  var os4 = detectOS(ua);
   var searchBotMatch = SEARCHBOT_OS_REGEX.exec(ua);
   if (searchBotMatch && searchBotMatch[1]) {
-    return new SearchBotDeviceInfo(name2, version3, os5, searchBotMatch[1]);
+    return new SearchBotDeviceInfo(name2, version3, os4, searchBotMatch[1]);
   }
-  return new BrowserInfo(name2, version3, os5);
+  return new BrowserInfo(name2, version3, os4);
 }
 function detectOS(ua) {
   for (var ii2 = 0, count = operatingSystemRules.length; ii2 < count; ii2++) {
-    var _a2 = operatingSystemRules[ii2], os5 = _a2[0], regex = _a2[1];
+    var _a2 = operatingSystemRules[ii2], os4 = _a2[0], regex = _a2[1];
     var match = regex.exec(ua);
     if (match) {
-      return os5;
+      return os4;
     }
   }
   return null;
@@ -32115,7 +32013,7 @@ function alphabet(letters) {
   };
 }
 // @__NO_SIDE_EFFECTS__
-function join3(separator = "") {
+function join4(separator = "") {
   astr("join", separator);
   return {
     encode: (from8) => {
@@ -32283,8 +32181,8 @@ function radix2(bits, revPadding = false) {
     }
   };
 }
-var base32 = /* @__PURE__ */ chain(/* @__PURE__ */ radix2(5), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ padding(5), /* @__PURE__ */ join3(""));
-var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join3(""));
+var base32 = /* @__PURE__ */ chain(/* @__PURE__ */ radix2(5), /* @__PURE__ */ alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), /* @__PURE__ */ padding(5), /* @__PURE__ */ join4(""));
+var genBase58 = /* @__NO_SIDE_EFFECTS__ */ (abc) => /* @__PURE__ */ chain(/* @__PURE__ */ radix(58), /* @__PURE__ */ alphabet(abc), /* @__PURE__ */ join4(""));
 var base58 = /* @__PURE__ */ genBase58("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
 
 // ../../node_modules/.pnpm/ox@0.9.3_typescript@5.7.3_zod@3.25.76/node_modules/ox/_esm/core/Secp256k1.js
@@ -41647,7 +41545,7 @@ var Os3 = ut4;
 init_dist3();
 init_dist();
 var fs5 = __toESM(require("fs"), 1);
-var path3 = __toESM(require("path"), 1);
+var path4 = __toESM(require("path"), 1);
 var crypto7 = __toESM(require("crypto"), 1);
 init_dist();
 var __require2 = /* @__PURE__ */ ((x6) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x6, {
@@ -41710,7 +41608,7 @@ var FileKeyValueStorage = class {
     const snapshot = JSON.stringify(Object.fromEntries(this.load()));
     const tmpPath = `${this.filePath}.tmp.${crypto7.randomBytes(8).toString("hex")}`;
     try {
-      fs5.mkdirSync(path3.dirname(this.filePath), { recursive: true, mode: 448 });
+      fs5.mkdirSync(path4.dirname(this.filePath), { recursive: true, mode: 448 });
       fs5.writeFileSync(tmpPath, snapshot, { encoding: "utf-8", mode: 384 });
       fs5.renameSync(tmpPath, this.filePath);
     } catch (err) {
@@ -41764,8 +41662,8 @@ function toRequestError(err) {
 }
 async function settleWithin(promise, ms3) {
   let timer;
-  const elapsed = new Promise((resolve2) => {
-    timer = setTimeout(resolve2, ms3);
+  const elapsed = new Promise((resolve4) => {
+    timer = setTimeout(resolve4, ms3);
   });
   try {
     await Promise.race([promise.catch(() => void 0), elapsed]);
@@ -41861,9 +41759,9 @@ var WalletConnectProvider = class extends WalletProvider {
   }
   /**
    * Returns the WC account to use as the `from` field for a signing request
-   * on `chainId`. EVM-only: throws `CHAIN_UNSUPPORTED` if `chainId` isn't in
-   * the `eip155` namespace. Accepts both CAIP-2 (`eip155:56`) and chain keys
-   * (`bsc`, `arbitrum`) — chain keys are normalised to CAIP-2 internally.
+   * on CAIP-2 chain `caip2`. EVM-only: throws `CHAIN_UNSUPPORTED` if it isn't
+   * in the `eip155` namespace. Callers convert chain keys first
+   * (caip2ForChainKey); CAIP-2 never leaves this class.
    *
    * Prefers an exact CAIP-2 match; falls back to any other `eip155:*` account
    * in the session. The fallback is safe because all EVM chains derive from
@@ -41872,59 +41770,61 @@ var WalletConnectProvider = class extends WalletProvider {
    * same-address property (see the April 2026 design notes on Bitcoin vs.
    * Bitcoin Cash derivations).
    */
-  resolveFromAddress(chainIdOrKey) {
-    const chainId = chainIdOrKey.includes(":") ? chainIdOrKey : (() => {
-      const def = getChainById(chainIdOrKey);
-      return def ? `${def.namespace}:${def.chainId}` : chainIdOrKey;
-    })();
-    const namespace = chainId.split(":")[0];
+  resolveFromAddress(caip2) {
+    const namespace = caip2.split(":")[0];
     if (namespace !== "eip155") {
       throw new WalletError(
         "CHAIN_UNSUPPORTED",
-        `WalletConnect signing is only supported for EVM chains (eip155:*). Got: ${chainIdOrKey}`
+        `WalletConnect signing is only supported for EVM chains (eip155:*). Got: ${caip2}`
       );
     }
     const accounts = this.getAllSessionAccounts();
-    const exact = accounts.find((a3) => a3.chainId === chainId);
+    const exact = accounts.find((a3) => a3.caip2 === caip2);
     if (exact) return exact.address;
-    const sameNs = accounts.find((a3) => a3.chainId.startsWith("eip155:"));
+    const sameNs = accounts.find((a3) => a3.caip2.startsWith("eip155:"));
     if (sameNs) return sameNs.address;
     throw new WalletError(
       "WC_NOT_CONNECTED",
-      `No account in WalletConnect session for chain ${chainIdOrKey}. Complete pairing and include this chain, then retry.`
+      `No account in WalletConnect session for chain ${caip2}. Complete pairing and include this chain, then retry.`
     );
   }
-  async getAddress(chainId) {
-    return this.resolveFromAddress(chainId);
+  async getAddress(chainKey) {
+    return this.resolveFromAddress(caip2Of(chainKey));
   }
+  /** The session's accounts, keyed by twak chain key (the WalletAddress
+   * contract); accounts on chains twak does not support are left out. */
   async getAddresses() {
-    return this.getAllSessionAccounts();
+    return this.getAllSessionAccounts().flatMap(({ address, caip2 }) => {
+      const chainKey = chainKeyForCaip2(caip2);
+      return chainKey ? [{ address, chainKey }] : [];
+    });
   }
-  async signMessage(chainId, message) {
+  async signMessage(chainKey, message) {
     const session = this.getActiveSession();
     if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
     const client = await this.ensureClient();
+    const caip2 = caip2Of(chainKey);
     const hexMessage = `0x${Buffer.from(message, "utf8").toString("hex")}`;
     return this.request(client, {
       topic: session.topic,
-      chainId,
+      chainId: caip2,
       request: {
         method: "personal_sign",
-        params: [hexMessage, this.resolveFromAddress(chainId)]
+        params: [hexMessage, this.resolveFromAddress(caip2)]
       }
     });
   }
-  async signTypedData(chainKey, chainId, typedDataJson) {
+  async signTypedData(chainKey, typedDataJson) {
     const session = this.getActiveSession();
     if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
     const client = await this.ensureClient();
-    const caipChainId = chainKey.includes(":") ? chainKey : `eip155:${chainId}`;
+    const caip2 = caip2Of(chainKey);
     return this.request(client, {
       topic: session.topic,
-      chainId: caipChainId,
+      chainId: caip2,
       request: {
         method: "eth_signTypedData_v4",
-        params: [this.resolveFromAddress(caipChainId), typedDataJson]
+        params: [this.resolveFromAddress(caip2), typedDataJson]
       }
     });
   }
@@ -41934,7 +41834,7 @@ var WalletConnectProvider = class extends WalletProvider {
    */
   async transfer(request) {
     const { chainKey } = request;
-    const chain2 = requireChain(chainKey);
+    const chain2 = chainOf(chainKey);
     if (chain2.namespace !== "eip155") {
       throw new TransferError(
         "CHAIN_UNSUPPORTED",
@@ -41948,13 +41848,13 @@ var WalletConnectProvider = class extends WalletProvider {
     const { contractAddress } = parseTokenId(request.assetId);
     if (contractAddress) {
       assertEvmAddress(contractAddress, "tokenAddress");
-      const { erc20: erc202 } = await Promise.resolve().then(() => (init_dist4(), dist_exports3));
+      const { erc20: erc202 } = await Promise.resolve().then(() => (init_dist4(), dist_exports2));
       const pending = await this.config.chainClient.contract(erc202).withAddress(contractAddress, chainKey).write.transfer([request.to, atomicAmount], this);
       return { hash: pending.hash, chainKey };
     }
     assertEvmAddress(request.to, "to");
     const hash = await this.sendTransaction({
-      chainId: `${chain2.namespace}:${chain2.chainId}`,
+      chainKey,
       to: request.to,
       data: "0x",
       value: "0x" + atomicAmount.toString(16)
@@ -41969,11 +41869,12 @@ var WalletConnectProvider = class extends WalletProvider {
     const session = this.getActiveSession();
     if (!session) throw new WalletError("WC_NOT_CONNECTED", WC_NOT_CONNECTED_MSG);
     const client = await this.ensureClient();
-    const namespace = params.chainId.split(":")[0];
+    const caip2 = caip2Of(params.chainKey);
+    const namespace = caip2.split(":")[0];
     if (namespace !== "eip155") {
       throw new WalletError(
         "CHAIN_UNSUPPORTED",
-        `WalletConnect signing is only supported for EVM chains (eip155:*). Got: ${params.chainId}`
+        `WalletConnect signing is only supported for EVM chains (eip155:*). Got: ${params.chainKey}`
       );
     }
     let value = params.value || "0x0";
@@ -41982,12 +41883,12 @@ var WalletConnectProvider = class extends WalletProvider {
     }
     return this.request(client, {
       topic: session.topic,
-      chainId: params.chainId,
+      chainId: caip2,
       request: {
         method: "eth_sendTransaction",
         params: [
           {
-            from: this.resolveFromAddress(params.chainId),
+            from: this.resolveFromAddress(caip2),
             to: params.to,
             data: params.data,
             value,
@@ -41998,9 +41899,6 @@ var WalletConnectProvider = class extends WalletProvider {
       }
     });
   }
-  supportsChain(chainId) {
-    return chainId.startsWith("eip155:");
-  }
   /**
    * Ends a session in two phases:
    *   1. Tell the peer wallet (best-effort, bounded by PEER_NOTIFY_TIMEOUT_MS:
@@ -42026,7 +41924,8 @@ var WalletConnectProvider = class extends WalletProvider {
    * existing session is revoked first: asking to pair again expresses the
    * intent to invalidate the previous one.
    */
-  async connect(chains = getDefaultWcChains()) {
+  async connect(chainKeys = getDefaultWcChainKeys()) {
+    const chains = chainKeys.map(caip2Of);
     const client = await this.ensureClient();
     const generation = ++this.pairingGeneration;
     for (const session of client.session.getAll()) {
@@ -42166,8 +42065,8 @@ var WalletConnectProvider = class extends WalletProvider {
         for (const account of accounts) {
           const parts = account.split(":");
           const address = parts[parts.length - 1];
-          const chainId = parts.slice(0, -1).join(":");
-          result.push({ address, chainId });
+          const caip2 = parts.slice(0, -1).join(":");
+          result.push({ address, caip2 });
         }
       }
     }
@@ -42179,11 +42078,11 @@ var WalletConnectProvider = class extends WalletProvider {
       if (accounts.length > 0) {
         const parts = accounts[0].split(":");
         const address = parts[parts.length - 1];
-        const chainId = parts.slice(0, -1).join(":");
+        const chainKey = chainKeyForCaip2(parts.slice(0, -1).join(":")) ?? void 0;
         return {
           topic: session.topic,
           address,
-          chainId,
+          chainKey,
           expiry: session.expiry,
           peerName: session.peer?.metadata?.name,
           peerIcon: session.peer?.metadata?.icons?.[0]
@@ -42193,7 +42092,6 @@ var WalletConnectProvider = class extends WalletProvider {
     return {
       topic: session.topic,
       address: "",
-      chainId: "",
       expiry: session.expiry,
       peerName: session.peer?.metadata?.name,
       peerIcon: session.peer?.metadata?.icons?.[0]
@@ -42201,8 +42099,8 @@ var WalletConnectProvider = class extends WalletProvider {
   }
 };
 var WC_SUPPORTED_NAMESPACES = /* @__PURE__ */ new Set(["eip155"]);
-function getDefaultWcChains() {
-  return Object.values(CHAINS).filter((c3) => WC_SUPPORTED_NAMESPACES.has(c3.namespace)).map((c3) => `${c3.namespace}:${c3.chainId}`);
+function getDefaultWcChainKeys() {
+  return mainnetChainKeysWhere((chain2) => WC_SUPPORTED_NAMESPACES.has(chain2.namespace));
 }
 function getNamespaceMethods(namespace) {
   switch (namespace) {
@@ -42275,7 +42173,7 @@ function registerInitCommand(program3) {
         if (opts.json) {
           output({ configured: true, source: "cli" }, true);
         } else {
-          success("Credentials saved to ~/.twak/credentials.json");
+          success(`Credentials saved to ${path5.join(twakHome(), "credentials.json")}`);
         }
         await tryRegisterWallet();
         if (!opts.json) {
@@ -42295,7 +42193,9 @@ function registerInitCommand(program3) {
         if (opts.json) {
           output({ configured: true, source: "env" }, true);
         } else {
-          success("Credentials saved from environment variables to ~/.twak/credentials.json");
+          success(
+            `Credentials saved from environment variables to ${path5.join(twakHome(), "credentials.json")}`
+          );
         }
         await tryRegisterWallet();
         if (!opts.json) {
@@ -42316,7 +42216,7 @@ function registerInitCommand(program3) {
             true
           );
         } else {
-          info("Configuration already exists at ~/.twak/");
+          info(`Configuration already exists at ${twakHome()}`);
           info(`  Access ID: ${existing.accessId.slice(0, 8)}...`);
           info(`  WC Project ID: ${existing.walletConnectProjectId || "not set"}`);
         }
@@ -42355,18 +42255,18 @@ var import_promises2 = require("fs/promises");
 var import_node_crypto = require("crypto");
 var import_promises = require("fs/promises");
 var import_node_path = require("path");
-async function writeAtomic(path7, contents, mode = 420) {
-  await (0, import_promises.mkdir)((0, import_node_path.dirname)(path7), { recursive: true });
+async function writeAtomic(path13, contents, mode = 420) {
+  await (0, import_promises.mkdir)((0, import_node_path.dirname)(path13), { recursive: true });
   let effectiveMode = mode;
   try {
-    const st4 = await (0, import_promises.stat)(path7);
+    const st4 = await (0, import_promises.stat)(path13);
     effectiveMode = st4.mode & 511;
   } catch {
   }
-  const tmpPath = `${path7}.tmp.${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
+  const tmpPath = `${path13}.tmp.${(0, import_node_crypto.randomBytes)(8).toString("hex")}`;
   await (0, import_promises.writeFile)(tmpPath, contents, { mode: effectiveMode });
   try {
-    await (0, import_promises.rename)(tmpPath, path7);
+    await (0, import_promises.rename)(tmpPath, path13);
   } catch (err) {
     try {
       await (0, import_promises.rm)(tmpPath, { force: true });
@@ -42376,6 +42276,52 @@ async function writeAtomic(path7, contents, mode = 420) {
   }
 }
 
+// src/setup/harnesses/types.ts
+init_dist();
+var TARGET_ENTRY = {
+  command: "twak",
+  args: ["serve"]
+};
+var TARGET_ENTRY_WATCH = {
+  command: "twak",
+  args: ["serve", "--watch"]
+};
+function targetEntry(watch2, env) {
+  const entry = watch2 ? TARGET_ENTRY_WATCH : TARGET_ENTRY;
+  return env.TWAK_HOME?.trim() ? { ...entry, env: { TWAK_HOME: twakHome(env) } } : entry;
+}
+function isTwakHomeOnlyEnv(env) {
+  if (!env || typeof env !== "object" || Array.isArray(env)) return false;
+  const keys2 = Object.keys(env);
+  return keys2.length === 1 && keys2[0] === "TWAK_HOME" && typeof env.TWAK_HOME === "string";
+}
+function parseEntry(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const entry = raw;
+  if (typeof entry.command !== "string") return null;
+  if (!Array.isArray(entry.args) || !entry.args.every((a3) => typeof a3 === "string")) return null;
+  const parsed = { command: entry.command, args: entry.args };
+  if (isTwakHomeOnlyEnv(entry.env)) parsed.env = { ...entry.env };
+  return parsed;
+}
+function isCanonicalEntry(entry) {
+  if (entry === null) return false;
+  if (entry.env !== void 0 && !isTwakHomeOnlyEnv(entry.env)) return false;
+  const shape = { command: entry.command, args: entry.args };
+  return entriesEqual(shape, TARGET_ENTRY) || entriesEqual(shape, TARGET_ENTRY_WATCH);
+}
+function envsEqual(a3 = {}, b3 = {}) {
+  const keys2 = Object.keys(a3);
+  return keys2.length === Object.keys(b3).length && keys2.every((k4) => a3[k4] === b3[k4]);
+}
+function entriesEqual(a3, b3) {
+  if (a3 === null || b3 === null) return a3 === b3;
+  if (a3.command !== b3.command) return false;
+  if (a3.args.length !== b3.args.length) return false;
+  if (!envsEqual(a3.env, b3.env)) return false;
+  return a3.args.every((arg, i2) => arg === b3.args[i2]);
+}
+
 // src/setup/harnesses/json-base.ts
 function createJsonMcpHarness(opts) {
   const { name: name2, displayName, configPath: configPath2 } = opts;
@@ -42401,12 +42347,7 @@ function createJsonMcpHarness(opts) {
     configPath: configPath2,
     async getCurrentEntry() {
       const config = await readConfig2();
-      const entry = config.mcpServers?.twak;
-      if (!entry || typeof entry !== "object") return null;
-      if (typeof entry.command !== "string") return null;
-      if (!Array.isArray(entry.args) || !entry.args.every((a3) => typeof a3 === "string"))
-        return null;
-      return { command: entry.command, args: entry.args };
+      return parseEntry(config.mcpServers?.twak);
     },
     async getRawEntry() {
       const config = await readConfig2();
@@ -42506,11 +42447,7 @@ var codex = {
   configPath,
   async getCurrentEntry() {
     const config = await readConfig();
-    const entry = config.mcp_servers?.twak;
-    if (!entry || typeof entry !== "object") return null;
-    if (typeof entry.command !== "string") return null;
-    if (!Array.isArray(entry.args) || !entry.args.every((a3) => typeof a3 === "string")) return null;
-    return { command: entry.command, args: entry.args };
+    return parseEntry(config.mcp_servers?.twak);
   },
   async getRawEntry() {
     const config = await readConfig();
@@ -42534,34 +42471,13 @@ var codex = {
 };
 var codex_default = codex;
 
-// src/setup/harnesses/types.ts
-var TARGET_ENTRY = {
-  command: "twak",
-  args: ["serve"]
-};
-var TARGET_ENTRY_WATCH = {
-  command: "twak",
-  args: ["serve", "--watch"]
-};
-function targetEntry(watch2) {
-  return watch2 ? TARGET_ENTRY_WATCH : TARGET_ENTRY;
-}
-function isCanonicalEntry(entry) {
-  return entriesEqual(entry, TARGET_ENTRY) || entriesEqual(entry, TARGET_ENTRY_WATCH);
-}
-function entriesEqual(a3, b3) {
-  if (a3 === null || b3 === null) return a3 === b3;
-  if (a3.command !== b3.command) return false;
-  if (a3.args.length !== b3.args.length) return false;
-  return a3.args.every((arg, i2) => arg === b3.args[i2]);
-}
-
 // src/setup/harnesses/index.ts
 var ALL_HARNESSES = [claude_code_default, claude_desktop_default, cursor_default, codex_default];
 
 // src/setup/phase-credentials.ts
 var import_prompts = require("@inquirer/prompts");
 init_dist2();
+var path6 = __toESM(require("path"));
 init_dist();
 var PORTAL_URL = "https://portal.trustwallet.com/dashboard/apps";
 var WC_DASHBOARD_URL = "https://dashboard.walletconnect.com/";
@@ -42632,11 +42548,13 @@ Set one only to use your own project. Get one at: ${WC_DASHBOARD_URL}
   success(`Saved access ID ${accessId.slice(0, 8)} to ${storageLocation(result.keychain)}`);
 }
 function storageLocation(keychain) {
-  return keychain ? "~/.twak/credentials.json (0600) + OS keychain (HMAC secret mirror)" : "~/.twak/credentials.json (0600); OS keychain unavailable, secret only on disk";
+  const file = path6.join(twakHome(), "credentials.json");
+  return keychain ? `${file} (0600) + OS keychain (HMAC secret mirror)` : `${file} (0600); OS keychain unavailable, secret only on disk`;
 }
 
 // src/setup/phase-harnesses.ts
 var import_prompts2 = require("@inquirer/prompts");
+var path7 = __toESM(require("path"));
 init_dist();
 
 // src/setup/skills.ts
@@ -42657,7 +42575,7 @@ function skillsAgentFor(harness) {
 }
 var SKILLS_TIMEOUT_MS = 12e4;
 var defaultSkillsInstaller = {
-  install: (agent) => new Promise((resolve2, reject) => {
+  install: (agent) => new Promise((resolve4, reject) => {
     const child = (0, import_node_child_process.spawn)(
       "npx",
       ["-y", "skills", "add", "trustwallet/tw-agent-skills", "-a", agent],
@@ -42681,7 +42599,7 @@ var defaultSkillsInstaller = {
     child.on(
       "exit",
       (code2) => settle(
-        () => code2 === 0 ? resolve2() : reject(new Error(`npx skills exited with code ${code2}`))
+        () => code2 === 0 ? resolve4() : reject(new Error(`npx skills exited with code ${code2}`))
       )
     );
   })
@@ -42692,12 +42610,17 @@ function indent(s2, spaces) {
   const prefix = " ".repeat(spaces);
   return s2.split("\n").map((line) => prefix + line).join("\n");
 }
+function entryHasForeignEnv(raw) {
+  return !!raw && typeof raw === "object" && !Array.isArray(raw) && "env" in raw && !isTwakHomeOnlyEnv(raw.env);
+}
 function entryHasExtras(raw) {
   if (!raw || typeof raw !== "object" || Array.isArray(raw)) return false;
-  return Object.keys(raw).some((k4) => k4 !== "command" && k4 !== "args");
+  return entryHasForeignEnv(raw) || Object.keys(raw).some(
+    (k4) => k4 !== "command" && k4 !== "args" && k4 !== "env"
+  );
 }
-function entryHasEnv(raw) {
-  return !!raw && typeof raw === "object" && !Array.isArray(raw) && "env" in raw;
+function entryFolder(entry) {
+  return entry.env?.TWAK_HOME ?? twakHome({});
 }
 var defaultPrompter2 = {
   selectHarnesses: (choices) => (0, import_prompts2.checkbox)({
@@ -42741,7 +42664,7 @@ async function runHarnessesPhase(opts, deps = makeDefaultDeps2()) {
   }
   if (opts.harness) {
     const writer = findHarness(deps.harnesses, opts.harness);
-    const entry = targetEntry(await deps.prompter.confirmWatch());
+    const entry = targetEntry(await deps.prompter.confirmWatch(), deps.env);
     await processHarness(writer, deps, true, entry);
     return;
   }
@@ -42754,7 +42677,7 @@ async function runMultiSelect(deps) {
     info("No harnesses selected. Re-run `twak setup --harness <name>` later to wire one.");
     return;
   }
-  const entry = targetEntry(await deps.prompter.confirmWatch());
+  const entry = targetEntry(await deps.prompter.confirmWatch(), deps.env);
   let wrote = 0;
   let removed = 0;
   for (const name2 of selected) {
@@ -42797,13 +42720,18 @@ async function processHarness(writer, deps, verbose, entry) {
   }
   if (current !== null && isCanonicalEntry(current) && !entryHasExtras(raw)) {
     info(`Updating ${writer.displayName} \u2192 ${writer.configPath()}`);
+    if (entryFolder(current) !== entryFolder(entry)) {
+      warn(
+        `${writer.displayName}: its twak server will use ${entryFolder(entry)} instead of ${entryFolder(current)}; a wallet or credentials in the old folder are not moved.`
+      );
+    }
     await writer.writeEntry(entry);
     await runSkillsInstall(writer.name, deps);
     return "wrote";
   }
-  if (entryHasEnv(raw)) {
+  if (entryHasForeignEnv(raw)) {
     warn(
-      `${writer.displayName} has an existing twak entry with an \`env\` block. Choosing Update will drop it; if it contained credentials, the harness will fall back to ~/.twak/credentials.json (run \`twak setup --reconfigure-creds\` to refresh) before restarting.`
+      `${writer.displayName} has an existing twak entry with an \`env\` block. Choosing Update will drop it; if it contained credentials, the harness will fall back to ${path7.join(twakHome(), "credentials.json")} (run \`twak setup --reconfigure-creds\` to refresh) before restarting.`
     );
   }
   const action = await deps.prompter.resolveConflict(writer.displayName, raw, entry);
@@ -42857,7 +42785,7 @@ async function runNonInteractive2(opts, deps) {
     );
   }
   const forceOverwrite = deps.env.TWAK_SETUP_FORCE_HARNESS_OVERWRITE === "1";
-  const entry = targetEntry(deps.env.TWAK_SETUP_WATCH === "1");
+  const entry = targetEntry(deps.env.TWAK_SETUP_WATCH === "1", deps.env);
   for (const name2 of names) {
     const writer = findHarness(deps.harnesses, name2);
     let current;
@@ -42882,9 +42810,9 @@ async function runNonInteractive2(opts, deps) {
       continue;
     }
     if (forceOverwrite) {
-      if (entryHasEnv(raw)) {
+      if (entryHasForeignEnv(raw)) {
         warn(
-          `${writer.displayName}: existing twak entry has an \`env\` block \u2014 dropping it because TWAK_SETUP_FORCE_HARNESS_OVERWRITE=1. If it held credentials, run \`twak setup --reconfigure-creds\` so they live in ~/.twak/credentials.json.`
+          `${writer.displayName}: existing twak entry has an \`env\` block \u2014 dropping it because TWAK_SETUP_FORCE_HARNESS_OVERWRITE=1. If it held credentials, run \`twak setup --reconfigure-creds\` so they live in ${path7.join(twakHome(), "credentials.json")}.`
         );
       } else {
         warn(
@@ -42915,6 +42843,7 @@ function findHarness(harnesses, name2) {
 var import_node_crypto2 = require("crypto");
 var import_prompts3 = require("@inquirer/prompts");
 init_dist2();
+var path8 = __toESM(require("path"));
 init_dist();
 
 // src/password.ts
@@ -42986,7 +42915,7 @@ function makeDefaultDeps3() {
       async create(pw) {
         await ensureTrustSDK();
         const provider = await AgentWalletProvider.create(pw);
-        const primaryAddress = await provider.getAddress("ethereum") ?? "<unknown>";
+        const primaryAddress = await provider.getAddress(knownChainKey("ethereum")) ?? "<unknown>";
         return { primaryAddress };
       }
     },
@@ -43041,7 +42970,7 @@ async function preflightWalletCreate(deps) {
   if (await deps.storage.exists()) {
     throw new WalletError(
       "WALLET_EXISTS",
-      "Wallet already exists. Back up ~/.twak/wallet.json, then delete it to create a new one."
+      `Wallet already exists. Back up ${path8.join(twakHome(), "wallet.json")}, then delete it to create a new one.`
     );
   }
   if (!deps.keychain.isAvailable()) {
@@ -43206,8 +43135,17 @@ function registerAuthCommand(program3) {
 
 // src/commands/wallet.ts
 var fs6 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
 init_dist2();
 var import_chalk6 = __toESM(require_source());
+
+// src/chain-options.ts
+init_dist();
+function parseChainList(value) {
+  return value.split(",").map((s2) => s2.trim()).filter(Boolean).map((s2) => resolveChain(s2));
+}
+
+// src/commands/wallet.ts
 init_dist();
 
 // ../operations/dist/index.mjs
@@ -43267,9 +43205,9 @@ var TransferExecutor = class {
   }
   async run(params) {
     const { wallet, swapClient, onInfo, onWarn } = this.deps;
-    const chainKey = resolveChain(params.chain);
+    const chainKey = params.chain;
     const contractAddress = params.tokenAddress && params.tokenAddress.toLowerCase() !== NATIVE_TOKEN_ADDRESS.toLowerCase() ? params.tokenAddress : void 0;
-    const { assetId } = resolveAsset(chainKey, contractAddress);
+    const assetId = assetIdOf(chainKey, contractAddress);
     const tokenInfo = resolveToken(assetId, chainKey);
     if (!tokenInfo) {
       throw new TransferError(
@@ -43455,10 +43393,9 @@ function getMemState(state, auto) {
 }
 function limitOrderAssetId(auto) {
   const tokenInfo = resolveToken(auto.toToken, auto.chain);
-  const chain2 = getChainById(auto.chain);
-  if (!tokenInfo || !chain2) return null;
+  if (!tokenInfo) return null;
   const isNative = tokenInfo.address === NATIVE_TOKEN_ADDRESS || tokenInfo.address === SOLANA_NATIVE_ADDRESS || !tokenInfo.address;
-  return formatTokenId(chain2.coinId, isNative ? void 0 : tokenInfo.address);
+  return formatTokenId(coinIdOf(auto.chain), isNative ? void 0 : tokenInfo.address);
 }
 function automationLabel(type) {
   return type === "dca" ? "DCA" : "Limit order";
@@ -43503,11 +43440,6 @@ async function processAutomation(auto, ctx) {
     ctx.result.automations.skipped++;
     return;
   }
-  if (!getChainById(auto.chain)) {
-    ctx.log("warn", `Automation ${auto.id.slice(0, 8)} skipped \u2014 unknown chain "${auto.chain}"`);
-    ctx.result.automations.skipped++;
-    return;
-  }
   if (auto.type === "dca") {
     const effectiveLastRunAt = memState ? memState.lastRunAt : auto.lastRunAt ?? null;
     const lastRun = effectiveLastRunAt ? new Date(effectiveLastRunAt).getTime() : 0;
@@ -43593,6 +43525,13 @@ async function runWatchTick(deps) {
   const activeAlerts = deps.alertStore ? await deps.alertStore.getActive() : [];
   const automations = await deps.automationStore.getActive();
   result.alerts.checked = activeAlerts.length;
+  for (const invalid of deps.alertStore ? await deps.alertStore.listInvalid() : []) {
+    log("warn", `Alert ${invalid.id.slice(0, 8)} not monitored: ${invalid.error}`);
+  }
+  for (const invalid of await deps.automationStore.listInvalid()) {
+    log("warn", `Automation ${invalid.id.slice(0, 8)} skipped: ${invalid.error}`);
+    result.automations.skipped++;
+  }
   const assetIds = new Set(activeAlerts.map((a3) => a3.tokenId));
   for (const auto of automations) {
     if (auto.type !== "limit") continue;
@@ -43676,16 +43615,15 @@ var Watcher = class {
 };
 function resolveAssets(addresses, chainKeys, { includeTokens = true } = {}) {
   const entries = chainKeys.flatMap((chainKey) => {
-    const chain2 = getChainById(chainKey);
-    const addrEntry = addresses.find((a3) => a3.chainId === chainKey);
-    if (!chain2 || !addrEntry) return [];
-    return [{ chainKey, chain: chain2, address: addrEntry.address }];
+    const addrEntry = addresses.find((a3) => a3.chainKey === chainKey);
+    if (!addrEntry) return [];
+    return [{ chainKey, chain: chainOf(chainKey), address: addrEntry.address }];
   });
   const natives = entries.map(({ chainKey, chain: chain2, address }) => ({
     chainKey,
     chain: chain2,
     token: void 0,
-    assetId: `c${chain2.coinId}`,
+    assetId: assetIdOf(chainKey),
     address
   }));
   if (!includeTokens) return natives;
@@ -43700,7 +43638,7 @@ function resolveAssets(addresses, chainKeys, { includeTokens = true } = {}) {
           chainKey,
           chain: chain2,
           token: { ...resolved, symbol: sym, decimals: knownTokens[sym].decimals },
-          assetId: `c${chain2.coinId}_t${resolved.address}`,
+          assetId: assetIdOf(chainKey, resolved.address),
           address
         }
       ];
@@ -43732,9 +43670,9 @@ function decodeAmount(amounts, decimals) {
 async function buildPortfolio(httpClient, { addresses, chains }) {
   let chainKeys;
   if (chains === void 0) {
-    chainKeys = Object.keys(CHAINS);
+    chainKeys = mainnetChainKeys();
   } else {
-    chainKeys = [...new Set(chains.map((s2) => s2.trim()).filter(Boolean))];
+    chainKeys = [...new Set(chains)];
     if (chainKeys.length === 0) {
       throw new WalletError("VALIDATION_ERROR", "chains must include at least one chain key");
     }
@@ -43823,12 +43761,12 @@ function box(content) {
 }
 
 // src/walletconnect-config.ts
-var path4 = __toESM(require("path"));
+var path9 = __toESM(require("path"));
 init_dist();
 init_dist2();
 var RESTORE_TIMEOUT_MS = 1e4;
 function wcStoragePath() {
-  return path4.join(new FileStore().getDataDir(), "walletconnect.json");
+  return path9.join(new FileStore().getDataDir(), "walletconnect.json");
 }
 var DEFAULT_WC_PROJECT_ID = "a863b78b54c4222603c8db4d6d880172";
 async function resolveWcProjectId(flag) {
@@ -43902,10 +43840,17 @@ async function getWalletConnectStatus(projectIdFlag) {
 }
 function registerWalletCommand(program3) {
   const wallet = program3.command("wallet").description("Manage agent wallet");
-  wallet.command("create").description("Create a new agent wallet").requiredOption("--password <password>", "Password to encrypt the wallet").option("--no-keychain", "Do not save password to OS keychain").option("--skip-password-check", "Skip password strength validation").option("--json", "JSON output").action(async (opts) => {
+  wallet.command("create").description("Create a new agent wallet").option("--password <password>", "Password to encrypt the wallet (or set TWAK_WALLET_PASSWORD)").option("--no-keychain", "Do not save password to OS keychain").option("--skip-password-check", "Skip password strength validation").option("--json", "JSON output").action(async (opts) => {
     try {
+      const password3 = opts.password || process.env.TWAK_WALLET_PASSWORD;
+      if (!password3) {
+        throw new WalletError(
+          "VALIDATION_ERROR",
+          "No wallet password: provide --password or set TWAK_WALLET_PASSWORD."
+        );
+      }
       if (!opts.skipPasswordCheck) {
-        const weakness = getPasswordWeaknesses(opts.password);
+        const weakness = getPasswordWeaknesses(password3);
         if (weakness) {
           throw new WalletError("VALIDATION_ERROR", `Password too weak: must ${weakness}.`);
         }
@@ -43915,15 +43860,15 @@ function registerWalletCommand(program3) {
       if (await store.exists()) {
         throw new WalletError(
           "WALLET_EXISTS",
-          "Wallet already exists. Back up ~/.twak/wallet.json, then delete it to create a new one."
+          `Wallet already exists. Back up ${path10.join(twakHome(), "wallet.json")}, then delete it to create a new one.`
         );
       }
-      const provider = await AgentWalletProvider.create(opts.password);
+      const provider = await AgentWalletProvider.create(password3);
       const addresses = await provider.getAddresses();
       if (opts.keychain !== false) {
         const kc2 = new KeychainManager();
         if (kc2.isAvailable()) {
-          await kc2.saveWalletPassword(opts.password);
+          await kc2.saveWalletPassword(password3);
           if (!opts.json) info("Password saved to OS keychain (use --no-keychain to skip)");
         }
       }
@@ -43936,7 +43881,10 @@ function registerWalletCommand(program3) {
         if (!opts.json) warn("Backend registration failed (holdings may be limited)");
       }
       if (opts.json) {
-        output({ addresses }, true);
+        output(
+          { addresses: addresses.map((a3) => ({ address: a3.address, chain: a3.chainKey })) },
+          true
+        );
       } else {
         info(`Generated addresses for ${addresses.length} chains`);
       }
@@ -43950,18 +43898,16 @@ function registerWalletCommand(program3) {
     "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)"
   ).option("--json", "JSON output").action(async (opts) => {
     try {
-      if (!getChainById(opts.chain)) {
-        throw new WalletError("CHAIN_UNSUPPORTED", `Unknown chain: ${opts.chain}`);
-      }
+      const chainKey = resolveChain(opts.chain);
       await ensureTrustSDK();
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
-      const address = await provider.getAddress(opts.chain);
+      const address = await provider.getAddress(chainKey);
       if (opts.json) {
-        output({ chain: opts.chain, address }, true);
+        output({ chain: chainKey, address }, true);
       } else {
         const qr3 = getQRString(address);
-        const content = `${import_chalk6.default.dim("Chain")}    ${import_chalk6.default.bold(opts.chain)}
+        const content = `${import_chalk6.default.dim("Chain")}    ${import_chalk6.default.bold(chainKey)}
 ${import_chalk6.default.dim("Address")}  ${import_chalk6.default.green(address)}
 
 ${qr3}`;
@@ -43982,12 +43928,15 @@ ${qr3}`;
       const provider = await AgentWalletProvider.fromStorage(password3);
       const addresses = await provider.getAddresses();
       if (opts.json) {
-        output({ addresses }, true);
+        output(
+          { addresses: addresses.map((a3) => ({ address: a3.address, chain: a3.chainKey })) },
+          true
+        );
       } else {
         const grouped = /* @__PURE__ */ new Map();
         for (const addr of addresses) {
           const chains = grouped.get(addr.address) ?? [];
-          chains.push(addr.chainId);
+          chains.push(addr.chainKey);
           grouped.set(addr.address, chains);
         }
         for (const [address, chains] of grouped) {
@@ -44035,21 +43984,15 @@ ${qr3}`;
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
       const httpClient = await getClient();
-      if (!opts.all) {
-        const chain2 = getChainById(opts.chain);
-        if (!chain2) {
-          throw new WalletError("CHAIN_UNSUPPORTED", `Unknown chain: ${opts.chain}`);
-        }
-      }
+      const requestedChains = opts.all ? mainnetChainKeys() : [resolveChain(opts.chain)];
       const allAddresses = await provider.getAddresses();
-      const requestedChains = opts.all ? Object.keys(CHAINS) : [opts.chain];
       const assets = resolveAssets(allAddresses, requestedChains, {
         includeTokens: opts.tokens !== false
       });
       if (!opts.all && assets.length === 0) {
         throw new WalletError(
           "CHAIN_UNSUPPORTED",
-          `Wallet does not have an address for chain: ${opts.chain}`
+          `Wallet does not have an address for chain: ${requestedChains[0]}`
         );
       }
       const joined = await fetchAssetBalances(httpClient, assets);
@@ -44184,14 +44127,14 @@ ${qr3}`;
     "WalletConnect project ID override (default: Trust Wallet project; or WALLETCONNECT_PROJECT_ID / twak init --wc-project-id)"
   ).option(
     "--chains <list>",
-    "Comma-separated CAIP-2 chain IDs (default: all supported EVM chains)"
+    "Comma-separated chains: keys, aliases or CAIP-2 IDs (default: all supported EVM chains)"
   ).option("--timeout <seconds>", "Connection timeout in seconds", "300").option("--json", "JSON output").action(async (opts) => {
     try {
       const projectId = await resolveWcProjectId(opts.projectId);
       const provider = createWalletConnectProvider(projectId, new ChainClient());
-      const chains = opts.chains ? opts.chains.split(",").map((s2) => s2.trim()).filter(Boolean) : getDefaultWcChains();
+      const chainKeys = opts.chains ? parseChainList(opts.chains) : void 0;
       info("Connecting via WalletConnect...");
-      const result = await provider.connect(chains);
+      const result = await provider.connect(chainKeys);
       const qr3 = getQRString(result.uri);
       if (qr3) {
         console.log(qr3);
@@ -44206,7 +44149,7 @@ ${qr3}`;
           {
             connected: true,
             address: session.address,
-            chainId: session.chainId,
+            chain: session.chainKey,
             peer: session.peerName
           },
           true
@@ -44214,7 +44157,7 @@ ${qr3}`;
       } else {
         success(`Connected to ${session.peerName || "wallet"}`);
         info(`  Address: ${session.address}`);
-        info(`  Chain:   ${session.chainId}`);
+        if (session.chainKey) info(`  Chain:   ${session.chainKey}`);
       }
     } catch (err) {
       handleCommandError(err, opts.json, "WalletConnect failed");
@@ -44252,7 +44195,7 @@ ${qr3}`;
       const exists = await store.exists();
       const kc2 = new KeychainManager();
       const keychainHasPassword = kc2.isAvailable() ? !!await kc2.getWalletPassword() : false;
-      const totalChains = Object.keys(CHAINS).length;
+      const totalChains = mainnetChainKeys().length;
       let createdAt;
       let addressCount;
       if (exists) {
@@ -44305,7 +44248,7 @@ ${qr3}`;
       const provider = await AgentWalletProvider.fromStorage(password3);
       const httpClient = await getClient();
       const addresses = await provider.getAddresses();
-      const chains = opts.chains !== void 0 ? opts.chains.split(",") : void 0;
+      const chains = opts.chains !== void 0 ? parseChainList(opts.chains) : void 0;
       const { rows, totalUsd } = await buildPortfolio(httpClient, { addresses, chains });
       if (opts.json) {
         output(rows, true);
@@ -44331,19 +44274,17 @@ ${qr3}`;
     "Wallet password (falls back to keychain / TWAK_WALLET_PASSWORD)"
   ).option("--json", "JSON output").action(async (opts) => {
     try {
-      const chain2 = getChainById(opts.chain);
-      if (!chain2) {
-        throw new WalletError("CHAIN_UNSUPPORTED", `Unknown chain: ${opts.chain}`);
-      }
+      const chainKey = resolveChain(opts.chain);
+      const chain2 = chainOf(chainKey);
       await ensureTrustSDK();
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
-      const address = await provider.getAddress(opts.chain);
-      const rawSignature = await provider.signMessage(opts.chain, opts.message);
+      const address = await provider.getAddress(chainKey);
+      const rawSignature = await provider.signMessage(chainKey, opts.message);
       const signature = chain2.isEVM && !rawSignature.startsWith("0x") ? `0x${rawSignature}` : rawSignature;
       output(
         {
-          chain: opts.chain,
+          chain: chainKey,
           address,
           message: opts.message,
           signature,
@@ -44380,20 +44321,23 @@ init_dist();
 init_dist3();
 init_dist();
 init_dist4();
+init_dist();
 var SwapClient = class {
   constructor(httpClient) {
     this.httpClient = httpClient;
   }
   async getQuote(params) {
-    const fromChain = getChainById(params.fromChain);
-    const toChain = getChainById(params.toChain);
-    if (!fromChain)
-      throw new TwakError(`Unsupported source chain: ${params.fromChain}`, "CHAIN_UNSUPPORTED");
-    if (!toChain)
-      throw new TwakError(`Unsupported destination chain: ${params.toChain}`, "CHAIN_UNSUPPORTED");
+    for (const chainKey of [params.fromChain, params.toChain]) {
+      if (isTestnet(chainKey)) {
+        throw new TwakError(
+          `Swaps are not supported on testnet chains (${chainKey})`,
+          "CHAIN_UNSUPPORTED"
+        );
+      }
+    }
     const domains = await getAmberDomainsByCoinId();
-    const fromDomain = domains.get(fromChain.coinId) ?? getChainDomainId(params.fromChain);
-    const toDomain = domains.get(toChain.coinId) ?? getChainDomainId(params.toChain);
+    const fromDomain = domains.get(coinIdOf(params.fromChain)) ?? backendIdOf(params.fromChain);
+    const toDomain = domains.get(coinIdOf(params.toChain)) ?? backendIdOf(params.toChain);
     const payload = {
       fromAsset: params.fromToken,
       fromAddress: params.walletAddress,
@@ -44440,7 +44384,7 @@ var SwapClient = class {
     return transactions;
   }
   async searchTokens(params) {
-    const coinIds = params.networks ? params.networks : (params.chains || Object.keys(CHAINS)).map((c3) => getChainById(c3)?.coinId).filter((id) => id != null).join(",");
+    const coinIds = params.networks ? params.networks : (params.chains ?? mainnetChainKeys()).map(coinIdOf).join(",");
     const queryParams = new URLSearchParams({
       networks: coinIds,
       exactQuery: params.query,
@@ -44460,18 +44404,16 @@ var SwapClient = class {
       name: doc.name,
       symbol: doc.symbol,
       address: this.extractAddressFromAssetId(doc.asset_id),
-      chain: this.getChainFromAssetId(doc.asset_id),
+      chain: this.chainOfAssetId(doc.asset_id),
       decimals: doc.decimals,
       logoUrl: doc.icon_url,
       priceUsd: doc.price?.price,
       priceChange24h: doc.price?.percent_change_24h
     }));
   }
-  async getTokenPrice(chainId, tokenAddress) {
-    const chain2 = getChainById(chainId);
-    if (!chain2) return null;
+  async getTokenPrice(chainKey, tokenAddress) {
     const isNative = tokenAddress === NATIVE_TOKEN_ADDRESS || tokenAddress === SOLANA_NATIVE_ADDRESS || !tokenAddress;
-    const assetId = formatTokenId(chain2.coinId, isNative ? void 0 : tokenAddress);
+    const assetId = formatTokenId(coinIdOf(chainKey), isNative ? void 0 : tokenAddress);
     try {
       const response = await this.httpClient.market("POST", "/v2/market/tickers", {
         currency: "USD",
@@ -44533,15 +44475,25 @@ var SwapClient = class {
       return "";
     }
   }
-  getChainFromAssetId(assetId) {
+  chainOfAssetId(assetId) {
     try {
-      const { coinId } = parseTokenId(assetId);
-      return coinTypeToChainKey(coinId) || "unknown";
+      return tokenIdToChain(assetId);
     } catch {
-      return "unknown";
+      return void 0;
     }
   }
 };
+var SIGNABLE_SOURCE_NAMESPACES = ["eip155", "solana"];
+function swapSourceUnsupportedReason(chainKey) {
+  if (isTestnet(chainKey)) {
+    return `Swaps are not supported on testnet chains (${chainKey}).`;
+  }
+  const chain2 = chainOf(chainKey);
+  if (!SIGNABLE_SOURCE_NAMESPACES.includes(chain2.namespace)) {
+    return `Swaps cannot start on ${chain2.name}: twak signs swap transactions on EVM chains and Solana only.`;
+  }
+  return void 0;
+}
 function classifySwapError(message) {
   const m2 = message.toLowerCase();
   if (m2.includes("insufficient funds") || m2.includes("exceeds balance"))
@@ -44558,6 +44510,8 @@ var SwapExecutor = class {
     this.options.onStatus?.(msg);
   }
   async execute(params) {
+    const unsupported = swapSourceUnsupportedReason(params.fromChain);
+    if (unsupported) throw new TwakError(unsupported, "CHAIN_UNSUPPORTED");
     const address = await this.walletProvider.getAddress(params.fromChain);
     const fromTokenInfo = resolveToken(params.fromToken, params.fromChain);
     if (!fromTokenInfo)
@@ -44612,7 +44566,7 @@ var SwapExecutor = class {
     this.log(
       `Swapping ${inputAmt} ${firstStep.from.asset.metadata.symbol} -> ${outputAmt} ${lastStep.to.asset.metadata.symbol} via ${route.steps.map((s2) => s2.provider.name).join(" -> ")}`
     );
-    const chainConfig = getChainById(params.fromChain);
+    const chainConfig = chainOf(params.fromChain);
     const transactions = await withRetry(() => this.swapClient.getSwapTransactions(route));
     let approvalHash;
     try {
@@ -44681,7 +44635,7 @@ var SwapExecutor = class {
       (t) => t.transaction.type === "approval" || t.transaction.type === "revokeApproval"
     );
     const stepApproval = route.steps[0].approval;
-    if (hasApprovalTx || !chainConfig?.isEVM || !stepApproval?.operatorAddress) return void 0;
+    if (hasApprovalTx || !chainConfig.isEVM || !stepApproval?.operatorAddress) return void 0;
     const fromAssetAddr = route.steps[0].from.asset.address;
     if (!fromAssetAddr || fromAssetAddr.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase())
       return void 0;
@@ -44695,15 +44649,15 @@ var SwapExecutor = class {
     return approveResult.hash;
   }
   async sendTransaction(txData, chainConfig, fromChain) {
-    if (chainConfig?.namespace === "solana" && txData.transaction.solanaTx) {
+    if (chainConfig.namespace === "solana" && txData.transaction.solanaTx) {
       return this.walletProvider.sendTransaction({
-        chainId: `solana:${chainConfig.chainId}`,
+        chainKey: fromChain,
         to: "",
         data: txData.transaction.solanaTx.serializedMessage
       });
     } else if (txData.transaction.evmTx) {
       return this.walletProvider.sendTransaction({
-        chainId: `eip155:${chainConfig?.chainId || "1"}`,
+        chainKey: fromChain,
         to: txData.transaction.evmTx.to,
         data: txData.transaction.evmTx.data,
         value: txData.transaction.evmTx.value || "0x0"
@@ -44822,7 +44776,7 @@ function registerTransferCommand(program3) {
         } catch {
           throw new TransferError("VALIDATION_ERROR", `Invalid token ID: ${opts.token}`);
         }
-        const resolvedKey = coinTypeToChainKey(coinId);
+        const resolvedKey = mainnetChainKeyForCoinId(coinId);
         if (!resolvedKey) {
           throw new TransferError(
             "CHAIN_UNSUPPORTED",
@@ -44938,7 +44892,7 @@ function registerSwapCommand(program3) {
         const detectChain = (token, fallback) => {
           const m2 = token.match(/^c(\d+)/i);
           if (m2) {
-            const key = coinTypeToChainKey(parseInt(m2[1]));
+            const key = mainnetChainKeyForCoinId(parseInt(m2[1], 10));
             if (!key)
               throw new SwapError(
                 "CHAIN_UNSUPPORTED",
@@ -44946,15 +44900,13 @@ function registerSwapCommand(program3) {
               );
             return key;
           }
-          return fallback;
+          return resolveChain(fallback);
         };
         const fromChain = detectChain(from8, opts.chain);
         const toChain = opts.toChain ? detectChain(to3, opts.toChain) : fromChain;
-        if (!getChainById(fromChain)) {
-          throw new SwapError("CHAIN_UNSUPPORTED", `Unknown chain: ${fromChain}`);
-        }
-        if (!getChainById(toChain)) {
-          throw new SwapError("CHAIN_UNSUPPORTED", `Unknown chain: ${toChain}`);
+        const unsupported = swapSourceUnsupportedReason(fromChain);
+        if (unsupported && !opts.quoteOnly) {
+          throw new SwapError("CHAIN_UNSUPPORTED", unsupported);
         }
         const fromInfo = resolveToken(from8, fromChain);
         if (!fromInfo) {
@@ -45001,7 +44953,7 @@ function registerSwapCommand(program3) {
         }
         const parsedAmount = parseAmount(resolvedAmount, fromDecimals);
         const needsWallet = !opts.quoteOnly;
-        let walletAddress = getChainById(fromChain)?.sampleAccount || "0x0000000000000000000000000000000000000000";
+        let walletAddress = chainOf(fromChain).sampleAccount;
         let provider = null;
         let destinationAddress;
         if (needsWallet) {
@@ -45115,7 +45067,7 @@ function resolveErc20WriteTarget(opts, nativeMsg) {
   if (!contractAddress) {
     throw new Erc20Error("NOT_ERC20", nativeMsg);
   }
-  const chainKey = coinTypeToChainKey(coinId);
+  const chainKey = mainnetChainKeyForCoinId(coinId);
   if (!chainKey) {
     throw new Erc20Error("CHAIN_UNSUPPORTED", `Unsupported coin type in asset ID: ${opts.token}`);
   }
@@ -45255,7 +45207,7 @@ function registerErc20Command(program3) {
           );
         }
         try {
-          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
           const wc3 = getWalletCore2();
           const ct5 = getCoinType2(coinId);
           if (ct5 && !wc3.CoinTypeExt.validate(ct5, parsed)) {
@@ -45267,7 +45219,7 @@ function registerErc20Command(program3) {
         } catch (err) {
           if (err instanceof CommandError) throw err;
         }
-        const k4 = coinTypeToChainKey(coinId);
+        const k4 = mainnetChainKeyForCoinId(coinId);
         if (!k4) {
           throw new Erc20Error(
             "CHAIN_UNSUPPORTED",
@@ -45331,10 +45283,13 @@ function registerErc8004Command(program3) {
       await ensureTrustSDK();
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
-      const ops = new Erc8004Operations(resolveErc8004Contract(new ChainClient(), opts.chain), {
-        signer: provider,
-        onInfo: info
-      });
+      const ops = new Erc8004Operations(
+        resolveErc8004Contract(new ChainClient(), resolveChain(opts.chain)),
+        {
+          signer: provider,
+          onInfo: info
+        }
+      );
       const result = await ops.register({
         agentURI: opts.uri,
         metadata: parseMetadataPairs(opts.metadata)
@@ -45370,10 +45325,13 @@ function registerErc8004Command(program3) {
       await ensureTrustSDK();
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
-      const ops = new Erc8004Operations(resolveErc8004Contract(new ChainClient(), opts.chain), {
-        signer: provider,
-        onInfo: info
-      });
+      const ops = new Erc8004Operations(
+        resolveErc8004Contract(new ChainClient(), resolveChain(opts.chain)),
+        {
+          signer: provider,
+          onInfo: info
+        }
+      );
       const result = await ops.setUri({ agentId, agentURI: opts.uri });
       success("agentURI updated!");
       output(
@@ -45401,10 +45359,13 @@ function registerErc8004Command(program3) {
       await ensureTrustSDK();
       const password3 = await resolvePassword(opts);
       const provider = await AgentWalletProvider.fromStorage(password3);
-      const ops = new Erc8004Operations(resolveErc8004Contract(new ChainClient(), opts.chain), {
-        signer: provider,
-        onInfo: info
-      });
+      const ops = new Erc8004Operations(
+        resolveErc8004Contract(new ChainClient(), resolveChain(opts.chain)),
+        {
+          signer: provider,
+          onInfo: info
+        }
+      );
       const result = await ops.setMetadata({ agentId, key: opts.key, value: opts.value });
       success("Metadata set!");
       output(
@@ -45431,7 +45392,9 @@ function registerErc8004Command(program3) {
     try {
       parseAgentId(agentId);
       await ensureTrustSDK();
-      const ops = new Erc8004Operations(resolveErc8004Contract(new ChainClient(), opts.chain));
+      const ops = new Erc8004Operations(
+        resolveErc8004Contract(new ChainClient(), resolveChain(opts.chain))
+      );
       const result = await ops.getMetadata({ agentId, key: opts.key });
       output(
         { agentId, key: result.key, value: result.value, chain: result.chainKey },
@@ -45450,7 +45413,9 @@ function registerErc8004Command(program3) {
     try {
       parseAgentId(agentId);
       await ensureTrustSDK();
-      const ops = new Erc8004Operations(resolveErc8004Contract(new ChainClient(), opts.chain));
+      const ops = new Erc8004Operations(
+        resolveErc8004Contract(new ChainClient(), resolveChain(opts.chain))
+      );
       const result = await ops.show({ agentId });
       output(
         {
@@ -45477,7 +45442,7 @@ var CHAIN_OPT = "EVM chain key (`bsc` and `bsctestnet` have known deployments)";
 var OPT_PARAMS_OPT = "Optional opaque optParams bytes passed through raw, as 0x-prefixed hex (defaults to empty)";
 var SUBMIT_OPT_PARAMS_OPT = `${OPT_PARAMS_OPT}. Evaluators may expect deliverable metadata here, e.g. hex-encoded UTF-8 JSON like {"deliverable_url": "..."}`;
 function buildOps(client, chainInput, signer) {
-  return new Erc8183Operations(resolveErc8183Contracts(client, chainInput), {
+  return new Erc8183Operations(resolveErc8183Contracts(client, resolveChain(chainInput)), {
     signer,
     onInfo: info,
     erc20At: (token, chainKey) => erc20.using(client).withAddress(token, chainKey),
@@ -46017,6 +45982,13 @@ init_dist();
 
 // ../security/dist/index.mjs
 init_dist();
+function chainOfAssetId(assetId) {
+  try {
+    return tokenIdToChain(assetId);
+  } catch {
+    return void 0;
+  }
+}
 var SecurityService = class {
   constructor(client) {
     this.client = client;
@@ -46055,10 +46027,14 @@ var SecurityService = class {
     }
   }
   async getAssetInfo(assetId) {
-    const info2 = await this.client.gateway(
+    const response = await this.client.gateway(
       "GET",
       `/v1/assets/${encodeURIComponent(assetId)}`
     );
+    delete response.network;
+    const raw = response;
+    const chain2 = chainOfAssetId(assetId);
+    const info2 = chain2 ? { ...raw, chain: chain2 } : raw;
     try {
       const priceResp = await this.client.market("POST", "/v2/market/tickers", { currency: "USD", assets: [assetId] });
       const ticker = priceResp.tickers?.[0];
@@ -46116,13 +46092,12 @@ var SecurityService = class {
       const price = doc.price || {};
       const market = doc.market || {};
       const assetIdRaw = asset.asset_id || doc.asset_id || "";
-      const coinId = assetIdRaw ? parseInt(assetIdRaw.replace(/^c/, "").split("_")[0], 10) : NaN;
-      const chain2 = !isNaN(coinId) ? coinTypeToChainKey(coinId) || "" : "";
+      const chain2 = chainOfAssetId(assetIdRaw);
       return {
         assetId: assetIdRaw,
         name: asset.name || doc.name || "",
         symbol: asset.symbol || doc.symbol || "",
-        chain: chain2,
+        ...chain2 ? { chain: chain2 } : {},
         logoUrl: asset.icon_url || doc.icon_url,
         priceUsd: price.price ?? doc.price_usd,
         priceChange24h: price.percent_change_24h ?? doc.price_change_24h,
@@ -46171,13 +46146,12 @@ var SecurityService = class {
     const tickers = response.tickers || [];
     const sortKey = sort === "market_cap" ? "market_cap" : sort === "volume_24h" ? "volume_24h" : "change_24h";
     return tickers.sort((a3, b3) => (b3[sortKey] ?? 0) - (a3[sortKey] ?? 0)).slice(0, limit).map((t) => {
-      const coinId = t.id ? parseInt(t.id.replace(/^c/, ""), 10) : NaN;
-      const chain2 = !isNaN(coinId) ? coinTypeToChainKey(coinId) || "" : "";
+      const chain2 = chainOfAssetId(t.id || "");
       return {
         assetId: t.id || "",
         name: t.slug || t.id || "",
         symbol: t.slug?.toUpperCase() || "",
-        chain: chain2,
+        ...chain2 ? { chain: chain2 } : {},
         logoUrl: void 0,
         priceUsd: t.price,
         priceChange24h: t.change_24h,
@@ -46247,22 +46221,19 @@ async function resolveTokenLabel(tokenId, service) {
   const cached = await assetCache.get(tokenId);
   if (cached !== void 0) return cached;
   try {
-    const { coinId, contractAddress } = parseTokenId(tokenId);
-    const chain2 = getChainByCoinId(coinId);
-    if (!chain2) return tokenId;
+    const { contractAddress } = parseTokenId(tokenId);
+    const chainKey = tokenIdToChain(tokenId);
+    if (!chainKey) return tokenId;
     if (!contractAddress) {
-      return chain2.symbol;
+      return chainOf(chainKey).symbol;
     }
-    const chainKey = tokenIdToChain(tokenId);
-    if (chainKey) {
-      const chainTokens = COMMON_TOKENS[chainKey];
-      if (chainTokens) {
-        const normalizedAddr = contractAddress.toLowerCase();
-        for (const [sym, entry] of Object.entries(chainTokens)) {
-          if (entry.address.toLowerCase() === normalizedAddr) {
-            await assetCache.set(tokenId, sym);
-            return sym;
-          }
+    const chainTokens = COMMON_TOKENS[chainKey];
+    if (chainTokens) {
+      const normalizedAddr = contractAddress.toLowerCase();
+      for (const [sym, entry] of Object.entries(chainTokens)) {
+        if (entry.address.toLowerCase() === normalizedAddr) {
+          await assetCache.set(tokenId, sym);
+          return sym;
         }
       }
     }
@@ -46277,7 +46248,7 @@ async function resolveTokenLabel(tokenId, service) {
       }
     }
     const short = contractAddress.length > 10 ? `${contractAddress.slice(0, 6)}\u2026${contractAddress.slice(-4)}` : contractAddress;
-    return `${chain2.symbol}/${short}`;
+    return `${chainOf(chainKey).symbol}/${short}`;
   } catch {
     return tokenId;
   }
@@ -46301,7 +46272,7 @@ function registerAlertCommand(program3) {
         throw new AlertError("VALIDATION_ERROR", "Price must be a positive number");
       }
       let resolvedTokenId = opts.token;
-      let resolvedChain = opts.chain;
+      let resolvedChain = opts.chain ? resolveChain(opts.chain) : void 0;
       try {
         parseTokenId(opts.token);
         if (!resolvedChain) {
@@ -46325,7 +46296,6 @@ function registerAlertCommand(program3) {
           AVAX: "avalanche",
           FTM: "fantom",
           TRX: "tron",
-          DOT: "polkadot",
           ATOM: "cosmos",
           NEAR: "near",
           APT: "aptos",
@@ -46337,7 +46307,7 @@ function registerAlertCommand(program3) {
           S: "sonic"
         };
         if (!resolvedChain && NATIVE_SYMBOLS2[sym]) {
-          resolvedChain = NATIVE_SYMBOLS2[sym];
+          resolvedChain = knownChainKey(NATIVE_SYMBOLS2[sym]);
         }
         if (!resolvedChain) {
           throw new AlertError(
@@ -46345,13 +46315,7 @@ function registerAlertCommand(program3) {
             `Cannot resolve "${opts.token}" without --chain. Provide --chain or use asset ID format (c60).`
           );
         }
-        const chain2 = getChainById(resolvedChain);
-        if (!chain2) {
-          throw new AlertError(
-            "CHAIN_UNSUPPORTED",
-            `Unknown chain: ${resolvedChain}. Run \`twak chains\` to see supported chains.`
-          );
-        }
+        const chain2 = chainOf(resolvedChain);
         const resolved = resolveToken(sym, resolvedChain);
         if (!resolved) {
           throw new AlertError(
@@ -46365,12 +46329,6 @@ function registerAlertCommand(program3) {
           resolvedTokenId = formatTokenId(chain2.coinId, resolved.address);
         }
       }
-      if (!isChainSupported(resolvedChain)) {
-        throw new AlertError(
-          "CHAIN_UNSUPPORTED",
-          `Unknown chain: ${resolvedChain}. Run \`twak chains\` to see supported chains.`
-        );
-      }
       const record2 = await alertStore.create({
         tokenId: resolvedTokenId,
         chainKey: resolvedChain,
@@ -46388,16 +46346,15 @@ function registerAlertCommand(program3) {
       const alerts = opts.active ? await alertStore.getActive() : await alertStore.list();
       const client = await tryGetClient();
       const service = client ? new SecurityService(client) : void 0;
+      for (const r3 of await alertStore.listInvalid()) {
+        warn(`Alert ${r3.id} is invalid: ${r3.error} (stored chain "${r3.chain}")`);
+      }
       if (opts.json) {
         const enriched = await Promise.all(
-          alerts.map(async (a3) => {
-            let chainLabel = a3.chainKey;
-            try {
-              chainLabel = tokenIdToChain(a3.tokenId) ?? a3.chainKey;
-            } catch {
-            }
-            return { ...a3, tokenLabel: await resolveTokenLabel(a3.tokenId, service), chainLabel };
-          })
+          alerts.map(async (a3) => ({
+            ...a3,
+            tokenLabel: await resolveTokenLabel(a3.tokenId, service)
+          }))
         );
         output(enriched, true);
       } else {
@@ -46407,15 +46364,8 @@ function registerAlertCommand(program3) {
         }
         for (const a3 of alerts) {
           const label = await resolveTokenLabel(a3.tokenId, service);
-          let chainHint = "";
-          try {
-            const chain2 = tokenIdToChain(a3.tokenId);
-            chainHint = chain2 ? ` (${chain2})` : "";
-          } catch {
-            chainHint = "";
-          }
           info(
-            `${a3.id} | ${label}${chainHint} | ${a3.condition} $${a3.targetPrice} | ${a3.active ? "active" : "triggered"}`
+            `${a3.id} | ${label} (${a3.chainKey}) | ${a3.condition} $${a3.targetPrice} | ${a3.active ? "active" : "triggered"}`
           );
         }
       }
@@ -46469,6 +46419,11 @@ function toRFC3339(value) {
   if (!isNaN(d3.getTime())) return d3.toISOString();
   return value;
 }
+function toRecord(raw, requested) {
+  const { chain: chain2, ...rest } = raw;
+  const chainKey = chain2 ? chainKeyForBackendId(chain2) : requested;
+  return chainKey ? { ...rest, chain: chainKey } : rest;
+}
 var TransactionService = class {
   constructor(client) {
     this.client = client;
@@ -46476,7 +46431,7 @@ var TransactionService = class {
   async getHistory(params) {
     const from8 = params.from ?? new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString();
     const to3 = params.to ?? (/* @__PURE__ */ new Date()).toISOString();
-    const chainId = params.chain ? getChainById(params.chain)?.id ?? params.chain : void 0;
+    const chainId = params.chain ? backendIdOf(params.chain) : void 0;
     const query = new URLSearchParams();
     query.set("address", params.address);
     if (params.asset) query.set("asset", params.asset);
@@ -46491,31 +46446,28 @@ var TransactionService = class {
       void 0,
       query.toString()
     );
-    return response.data || [];
+    return (response.data || []).map((r3) => toRecord(r3, params.chain));
   }
   async getBulkHistory(params) {
     const from8 = params.from ?? new Date(Date.now() - 30 * 24 * 60 * 60 * 1e3).toISOString();
     const to3 = params.to ?? (/* @__PURE__ */ new Date()).toISOString();
-    const addresses = params.addresses.map((a3) => ({
-      ...a3,
-      chain: getChainById(a3.chain)?.id ?? a3.chain
-    }));
+    const addresses = params.addresses.map((a3) => ({ ...a3, chain: backendIdOf(a3.chain) }));
     const response = await this.client.gateway("POST", "/v1/txhub/bulk_history", {
       addresses,
       from: toRFC3339(from8),
       to: toRFC3339(to3),
       ...params.nextToken ? { next_token: params.nextToken } : {}
     });
-    return response.data || [];
+    return (response.data || []).map((r3) => toRecord(r3));
   }
   async getByHash(hash, chain2) {
-    const chainId = getChainById(chain2)?.id ?? chain2;
-    return this.client.gateway(
+    const record2 = await this.client.gateway(
       "GET",
       `/v1/txhub/txs/${hash}`,
       void 0,
-      `chain=${chainId}`
+      `chain=${backendIdOf(chain2)}`
     );
+    return toRecord(record2, chain2);
   }
   async getSwapHistory(params) {
     return this.getHistory({ ...params, txType: "swap" });
@@ -46537,39 +46489,34 @@ function registerQueryCommand(program3) {
       const client = await getClient();
       const swapClient = new SwapClient(client);
       const tokens = token.split(",").map((t) => t.trim()).filter(Boolean);
-      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(
-          ([, c3]) => c3.symbol.toUpperCase() === t.toUpperCase()
-        )?.[0];
-        if (bySymbol) return bySymbol;
+      const explicitChain = opts.chain ? resolveChain(opts.chain) : void 0;
+      const homeChainOf = (t) => {
+        if (explicitChain) return explicitChain;
+        const lower = t.toLowerCase();
         const upper = t.toUpperCase();
-        for (const [chainKey, chainTokens] of Object.entries(COMMON_TOKENS)) {
-          if (Object.prototype.hasOwnProperty.call(chainTokens, upper)) return chainKey;
-        }
-        return "ethereum";
-      };
-      if (opts.chain && !getChainById(opts.chain)) {
-        throw new QueryError(
-          "CHAIN_UNSUPPORTED",
-          `Unknown chain: ${opts.chain}. Run 'twak chains' to list supported chains.`
+        const byName = mainnetChainKeys().find((k4) => k4 === lower);
+        if (byName) return byName;
+        const bySymbol = mainnetChainKeys().find(
+          (k4) => chainOf(k4).symbol.toUpperCase() === upper
         );
-      }
+        if (bySymbol) return bySymbol;
+        const byToken = chainKeysWithKnownTokens().find(
+          (k4) => Object.prototype.hasOwnProperty.call(COMMON_TOKENS[k4], upper)
+        );
+        return byToken ?? knownChainKey("ethereum");
+      };
       if (tokens.length > 1) {
         const assetIds = [];
         const tokenMeta = [];
         for (const t of tokens) {
-          const chain3 = resolveChain2(t);
+          const chain3 = homeChainOf(t);
           const info2 = resolveToken(t, chain3);
           if (!info2) {
             warn(`Unknown token: ${t.toUpperCase()}`);
             continue;
           }
-          const chainInfo = getChainById(chain3);
-          if (!chainInfo) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown chain: ${chain3}`);
           const isNative = !info2.address || info2.address === NATIVE_TOKEN_ADDRESS || info2.address === SOLANA_NATIVE_ADDRESS;
-          const assetId = isNative ? `c${chainInfo.coinId}` : `c${chainInfo.coinId}_t${info2.address}`;
+          const assetId = isNative ? assetIdOf(chain3) : assetIdOf(chain3, info2.address);
           assetIds.push(assetId);
           tokenMeta.push({ token: t.toUpperCase(), chain: chain3 });
         }
@@ -46605,7 +46552,7 @@ function registerQueryCommand(program3) {
         }
         return;
       }
-      const chain2 = resolveChain2(token);
+      const chain2 = homeChainOf(token);
       const tokenInfo = resolveToken(token, chain2);
       let price = null;
       if (tokenInfo) {
@@ -46635,10 +46582,8 @@ function registerQueryCommand(program3) {
           );
         }
         const period = typeof opts.history === "string" ? opts.history : "week";
-        const chainInfo = getChainById(chain2);
-        if (!chainInfo) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown chain: ${chain2}`);
         const isNative = !tokenInfo.address || tokenInfo.address === NATIVE_TOKEN_ADDRESS || tokenInfo.address === SOLANA_NATIVE_ADDRESS;
-        const assetId = isNative ? `c${chainInfo.coinId}` : `c${chainInfo.coinId}_t${tokenInfo.address}`;
+        const assetId = isNative ? assetIdOf(chain2) : assetIdOf(chain2, tokenInfo.address);
         const chartData = await client.gateway("GET", `/v1/market/charts/${assetId}`, void 0, `currency=USD&period=${period}`);
         output(
           { token: token.toUpperCase(), chain: chain2, priceUsd: price, history: chartData.prices },
@@ -46665,12 +46610,7 @@ function registerQueryCommand(program3) {
         networks = opts.networks.split(",").map((n4) => {
           const trimmed = n4.trim();
           if (/^\d+$/.test(trimmed)) return trimmed;
-          const chain2 = getChainById(trimmed);
-          if (chain2) return String(chain2.coinId);
-          throw new QueryError(
-            "CHAIN_UNSUPPORTED",
-            `Unknown network "${trimmed}". Use a supported chain name or numeric coin ID.`
-          );
+          return String(coinIdOf(resolveChain(trimmed)));
         }).join(",");
       }
       const result = await swapClient.searchTokens({
@@ -46687,22 +46627,17 @@ function registerQueryCommand(program3) {
     try {
       const client = await getClient();
       const service = new TransactionService(client);
-      if (opts.chain && !getChainById(opts.chain)) {
-        throw new QueryError(
-          "CHAIN_UNSUPPORTED",
-          `Unknown chain: ${opts.chain}. Run 'twak chains' to list supported chains.`
-        );
-      }
-      if (opts.address && opts.chain && !/^(0x[0-9a-fA-F]{40}|[1-9A-HJ-NP-Za-km-z]{20,}|[A-Za-z0-9]{20,})$/.test(opts.address)) {
+      const chainKey = opts.chain ? resolveChain(opts.chain) : void 0;
+      if (opts.address && chainKey && !/^(0x[0-9a-fA-F]{40}|[1-9A-HJ-NP-Za-km-z]{20,}|[A-Za-z0-9]{20,})$/.test(opts.address)) {
         throw new QueryError("VALIDATION_ERROR", `Invalid address: "${opts.address}"`);
       }
-      if (!opts.chain) {
+      if (!chainKey) {
         await ensureTrustSDK();
         const password3 = await resolvePassword(opts);
         const provider = await AgentWalletProvider.fromStorage(password3);
         const allAddresses = await provider.getAddresses();
         const addresses = allAddresses.map((wa2) => ({
-          chain: wa2.chainId,
+          chain: wa2.chainKey,
           address: wa2.address
         }));
         const result2 = await service.getBulkHistory({
@@ -46725,46 +46660,42 @@ function registerQueryCommand(program3) {
         await ensureTrustSDK();
         const password3 = await resolvePassword(opts);
         const provider = await AgentWalletProvider.fromStorage(password3);
-        address = await provider.getAddress(opts.chain);
+        address = await provider.getAddress(chainKey);
       }
       const result = await service.getHistory({
         address,
-        chain: opts.chain,
+        chain: chainKey,
         from: opts.from,
         to: opts.to,
         limit: parseInt(opts.limit, 10)
       });
       if (result.length > 0) {
-        const chain2 = getChainById(opts.chain);
-        if (chain2) {
-          const swapClient = new SwapClient(client);
-          const price = await swapClient.getTokenPrice(opts.chain, "");
-          const enriched = result.map((tx) => {
-            if (!tx.amount || tx.amount === "0") return tx;
-            try {
-              const big = BigInt(tx.amount);
-              const divisor = 10n ** BigInt(chain2.decimals);
-              const intPart = big / divisor;
-              const scale = 10000n;
-              const fracScaled = big % divisor * scale / divisor;
-              const usdValue = price !== null && (intPart > 0n || fracScaled > 0n) && intPart <= BigInt(Number.MAX_SAFE_INTEGER) ? parseFloat(
-                ((Number(intPart) + Number(fracScaled) / 1e4) * price).toFixed(4)
-              ) : void 0;
-              return { ...tx, usdValue };
-            } catch {
-              return tx;
-            }
-          });
-          output(enriched, opts.json);
-          return;
-        }
+        const chain2 = chainOf(chainKey);
+        const swapClient = new SwapClient(client);
+        const price = await swapClient.getTokenPrice(chainKey, "");
+        const enriched = result.map((tx) => {
+          if (!tx.amount || tx.amount === "0") return tx;
+          try {
+            const big = BigInt(tx.amount);
+            const divisor = 10n ** BigInt(chain2.decimals);
+            const intPart = big / divisor;
+            const scale = 10000n;
+            const fracScaled = big % divisor * scale / divisor;
+            const usdValue = price !== null && (intPart > 0n || fracScaled > 0n) && intPart <= BigInt(Number.MAX_SAFE_INTEGER) ? parseFloat(((Number(intPart) + Number(fracScaled) / 1e4) * price).toFixed(4)) : void 0;
+            return { ...tx, usdValue };
+          } catch {
+            return tx;
+          }
+        });
+        output(enriched, opts.json);
+        return;
       }
       if (opts.json) {
         output(result, true);
       } else if (result.length === 0) {
-        const explorer = opts.chain === "ethereum" ? "etherscan.io" : opts.chain === "bsc" ? "bscscan.com" : void 0;
-        const hint = explorer ? ` Check ${explorer} for full history.` : "";
-        info(`No transactions found via API.${hint}`);
+        info(
+          `No transactions found via API. Check ${chainOf(chainKey).explorerUrl} for full history.`
+        );
       } else {
         output(result, false);
       }
@@ -46775,30 +46706,25 @@ function registerQueryCommand(program3) {
   });
   program3.command("tx <hash>").description("Get transaction details by hash (on-chain RPC lookup)").requiredOption("--chain <name>", "Chain name").option("--address <address>", "Wallet address (auto-detected from wallet if omitted)").option("--password <pw>", "Wallet password (for auto-detecting address)").option("--json", "JSON output").action(async (hash, opts) => {
     try {
-      if (!getChainById(opts.chain)) {
-        throw new QueryError(
-          "CHAIN_UNSUPPORTED",
-          `Unknown chain: ${opts.chain}. Run 'twak chains' to list supported chains.`
-        );
-      }
+      const chainKey = resolveChain(opts.chain);
       let address = opts.address;
       if (!address) {
         try {
           await ensureTrustSDK();
           const password3 = await resolvePassword(opts);
           const provider = await AgentWalletProvider.fromStorage(password3);
-          address = await provider.getAddress(opts.chain);
+          address = await provider.getAddress(chainKey);
         } catch {
         }
       }
       if (address) {
         await ensureTrustSDK();
         const chainClient = new ChainClient();
-        const status = await chainClient.findTransactionStatus(opts.chain, address, hash);
+        const status = await chainClient.findTransactionStatus(chainKey, address, hash);
         output(
           {
             hash,
-            chain: opts.chain,
+            chain: chainKey,
             ...status
           },
           opts.json
@@ -46806,7 +46732,7 @@ function registerQueryCommand(program3) {
       } else {
         const client = await getClient();
         const service = new TransactionService(client);
-        const result = await service.getByHash(hash, opts.chain);
+        const result = await service.getByHash(hash, chainKey);
         output(result, opts.json);
       }
     } catch (err) {
@@ -46814,15 +46740,14 @@ function registerQueryCommand(program3) {
     }
   });
   program3.command("chains").description("List supported chains").option("--json", "JSON output").action(async (opts) => {
-    const chainEntries = Object.entries(CHAINS);
+    const chainEntries = mainnetChainKeys().map((key) => [key, chainOf(key)]);
     if (opts.json) {
       output(
         chainEntries.map(([key, chain2]) => ({
-          key,
+          chain: key,
           name: chain2.name,
           symbol: chain2.symbol,
           namespace: chain2.namespace,
-          chainId: chain2.id,
           coinId: chain2.coinId
         })),
         true
@@ -46852,23 +46777,23 @@ function registerQueryCommand(program3) {
   });
   program3.command("balance").description("Get token balance for an address (native or ERC-20)").requiredOption("--address <address>", "Wallet address").option("--coin <coinId>", "SLIP44 coin ID (for native token)").option("--chain <key>", "Chain key (e.g., ethereum, bsc)").option("--token <address>", "Token contract address (for ERC-20)").option("--json", "JSON output").action(async (opts) => {
     try {
-      let coinId;
-      if (opts.coin) {
-        coinId = Number(opts.coin);
-        if (!Number.isInteger(coinId))
+      let chainKey;
+      if (opts.chain) {
+        chainKey = resolveChain(opts.chain);
+      } else if (opts.coin) {
+        if (!/^\d+$/.test(String(opts.coin)))
           throw new QueryError("VALIDATION_ERROR", `Invalid coin ID: ${opts.coin}`);
-      } else if (opts.chain) {
-        const chainInfo = getChainById(opts.chain);
-        if (!chainInfo) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown chain: ${opts.chain}`);
-        coinId = chainInfo.coinId;
+        const byCoin = mainnetChainKeyForCoinId(parseTokenId(`c${opts.coin}`).coinId);
+        if (!byCoin) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown coin ID: ${opts.coin}`);
+        chainKey = byCoin;
       } else {
         throw new QueryError("VALIDATION_ERROR", "Provide --coin or --chain");
       }
-      const chain2 = getChainByCoinId(coinId);
-      if (!chain2) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown coin ID: ${coinId}`);
+      const chain2 = chainOf(chainKey);
+      const coinId = chain2.coinId;
       try {
         await ensureTrustSDK();
-        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+        const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
         const wc3 = getWalletCore2();
         const ct5 = getCoinType2(coinId);
         if (ct5 && !wc3.CoinTypeExt.validate(ct5, opts.address)) {
@@ -46877,13 +46802,12 @@ function registerQueryCommand(program3) {
       } catch (err) {
         if (err instanceof CommandError) throw err;
       }
-      const assetId = opts.token ? `c${coinId}_t${opts.token}` : `c${coinId}`;
+      const assetId = assetIdOf(chainKey, opts.token);
       const httpClient = await getClient();
       let decimals = chain2.decimals;
       let symbol = chain2.symbol;
       if (opts.token) {
         const swapClient = new SwapClient(httpClient);
-        const chainKey = opts.chain || Object.entries(CHAINS).find(([, c3]) => c3.coinId === coinId)?.[0] || "";
         const tokens = await swapClient.searchTokens({
           query: opts.token,
           chains: [chainKey],
@@ -46901,7 +46825,7 @@ function registerQueryCommand(program3) {
         output(
           {
             address: opts.address,
-            chain: chain2.id,
+            chain: chainKey,
             symbol,
             ...opts.token ? { token: opts.token } : {},
             decimalsKnown: false,
@@ -46920,7 +46844,7 @@ function registerQueryCommand(program3) {
       output(
         {
           address: opts.address,
-          chain: chain2.id,
+          chain: chainKey,
           symbol,
           ...opts.token ? { token: opts.token } : {},
           available: formatAmount(amts.available ?? "0", decimals),
@@ -46954,29 +46878,33 @@ function registerQueryCommand(program3) {
           "Provide --chain <key> or --asset-id <id> to validate an address"
         );
       }
-      let assetId = opts.assetId;
-      if (!assetId && opts.chain) {
-        const chain2 = getChainById(opts.chain);
-        if (!chain2) throw new QueryError("CHAIN_UNSUPPORTED", `Unknown chain: ${opts.chain}`);
-        assetId = `c${chain2.coinId}`;
+      let chainKey;
+      if (opts.chain) {
+        chainKey = resolveChain(opts.chain);
+      } else {
+        try {
+          chainKey = tokenIdToChain(opts.assetId);
+        } catch {
+          chainKey = void 0;
+        }
       }
+      const assetId = opts.assetId ?? (chainKey ? assetIdOf(chainKey) : void 0);
       if (assetId) {
         const coinIdStr = assetId.replace(/^c/, "").split("_")[0];
         const coinId = parseInt(coinIdStr, 10);
         try {
           await ensureTrustSDK();
-          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports2));
+          const { getWalletCore: getWalletCore2, getCoinType: getCoinType2 } = await Promise.resolve().then(() => (init_dist3(), dist_exports));
           const wc3 = getWalletCore2();
           const ct5 = getCoinType2(coinId);
           if (ct5) {
             const isValid = wc3.CoinTypeExt.validate(ct5, opts.address);
             if (!isValid) {
-              const chainInfo = getChainByCoinId(coinId);
-              const label = chainInfo?.name ?? `coin ${coinId}`;
+              const label = chainKey ? chainOf(chainKey).name : `coin ${coinId}`;
               const result = {
                 status: "error",
                 valid: false,
-                chain: chainInfo?.id,
+                ...chainKey ? { chain: chainKey } : {},
                 message: `Invalid address format for ${label}`
               };
               output(result, opts.json);
@@ -46989,11 +46917,6 @@ function registerQueryCommand(program3) {
       const client = await getClient();
       const service = new SecurityService(client);
       const backendResult = await service.validate({ address: opts.address, assetId });
-      const chainKey = opts.chain || (assetId ? (() => {
-        const coinIdStr = assetId.replace(/^c/, "").split("_")[0];
-        const coinId = parseInt(coinIdStr, 10);
-        return getChainByCoinId(coinId)?.id;
-      })() : void 0);
       const enriched = { ...backendResult, ...chainKey ? { chain: chainKey } : {} };
       output(enriched, opts.json);
     } catch (err) {
@@ -47127,6 +47050,7 @@ init_dist();
 var import_zod3 = require("zod");
 init_dist();
 var import_zod4 = require("zod");
+init_dist();
 var import_zod5 = require("zod");
 init_dist();
 var import_zod6 = require("zod");
@@ -47373,11 +47297,7 @@ async function signTransferWithAuthorization(p3) {
     domain: p3.token,
     message: authorization
   });
-  const rawSignature = await p3.walletProvider.signTypedData(
-    p3.chainKey,
-    p3.token.chainId,
-    JSON.stringify(typedData)
-  );
+  const rawSignature = await p3.walletProvider.signTypedData(p3.chainKey, JSON.stringify(typedData));
   const signature = normalizeEip712Signature(rawSignature);
   return { signature, authorization };
 }
@@ -47442,11 +47362,7 @@ async function signPermit2Authorization(p3) {
     witnessTo: p3.payTo,
     validAfter
   });
-  const rawSignature = await p3.walletProvider.signTypedData(
-    p3.chainKey,
-    p3.chainId,
-    JSON.stringify(typedData)
-  );
+  const rawSignature = await p3.walletProvider.signTypedData(p3.chainKey, JSON.stringify(typedData));
   const signature = normalizeEip712Signature(rawSignature);
   return {
     signature,
@@ -47535,7 +47451,6 @@ async function payAndFetch(args) {
       amount: getAmount(kind),
       tokenName,
       asset: getAsset(kind),
-      network: getNetwork(kind),
       chainKey,
       payTo: getPayTo(kind)
     });
@@ -47605,7 +47520,7 @@ async function payAndFetch(args) {
     payment = {
       amount,
       tokenName,
-      network: getNetwork(kind),
+      chain: chainKey,
       payTo: getPayTo(kind),
       nonce
     };
@@ -47638,7 +47553,7 @@ async function ensurePermit2Allowance(args) {
   };
   const approved = await args.confirmApproval?.(ctx) === true;
   if (!approved) {
-    const assetId = formatTokenId(CHAINS[args.chainKey].coinId, args.tokenAddress);
+    const assetId = formatTokenId(coinIdOf(args.chainKey), args.tokenAddress);
     throw new X402Error(
       "PERMIT2_APPROVAL_REQUIRED",
       `Permit2 needs a one-time approval for ${args.tokenAddress} on ${args.chainKey}. Run: twak erc20 approve --token ${assetId} --spender ${PERMIT2_ADDRESS} --amount unlimited`
@@ -47735,29 +47650,16 @@ async function validateX402Url(urlStr) {
   }
 }
 function parseNetwork(network) {
-  const caip = /^eip155:(\d+)$/.exec(network);
-  if (caip) {
-    const evmChainId = parseInt(caip[1], 10);
-    const entry2 = Object.entries(CHAINS).find(([, c3]) => c3.chainId === String(evmChainId));
-    if (!entry2) {
-      throw new X402Error("CHAIN_UNSUPPORTED", `x402: unsupported chain eip155:${evmChainId}`);
-    }
-    return { evmChainId, chainKey: entry2[0] };
-  }
   const lower = network.toLowerCase();
-  const entry = Object.entries(CHAINS).find(
-    ([key, c3]) => key === lower || c3.id.toLowerCase() === lower
-  );
-  if (!entry) {
+  const chainKey = /^eip155:\d+$/.test(network) ? chainKeyForCaip2(network) ?? void 0 : mainnetChainKeys().find((key) => key === lower) ?? chainKeyForBackendId(lower);
+  if (!chainKey || isTestnet(chainKey) || chainOf(chainKey).namespace !== "eip155") {
     throw new X402Error("CHAIN_UNSUPPORTED", `x402: unsupported network "${network}"`);
   }
-  return { evmChainId: parseInt(entry[1].chainId, 10), chainKey: entry[0] };
+  return { evmChainId: evmChainIdOf(chainKey), chainKey };
 }
 function networkMatches(kind, prefer) {
-  const lower = prefer.toLowerCase();
-  if (getNetwork(kind).toLowerCase() === lower) return true;
   try {
-    return parseNetwork(getNetwork(kind)).chainKey.toLowerCase() === lower;
+    return parseNetwork(getNetwork(kind)).chainKey === prefer;
   } catch {
     return false;
   }
@@ -47930,7 +47832,7 @@ async function quoteX402(args) {
   }
   const accepts = payableAccepts.map((kind) => {
     const transferMethod = effectiveTransferMethod(kind);
-    const network = getNetwork(kind);
+    const { chainKey: chain2 } = parseNetwork(getNetwork(kind));
     const asset = getAsset(kind);
     const amount = getAmount(kind);
     const extra = getExtra(kind);
@@ -47939,7 +47841,7 @@ async function quoteX402(args) {
     const tokenLabel = tokenName || asset;
     const approvalTag = requiresApproval ? " (Permit2, requires one-time on-chain approval the first time you pay this token on this chain)" : " (gasless)";
     return {
-      network,
+      chain: chain2,
       scheme: getScheme(kind),
       asset,
       tokenName,
@@ -47955,7 +47857,7 @@ async function quoteX402(args) {
       // strip control chars to defend against terminal-escape injection.
       // Raw values stay on the structured `tokenName` / `transferMethod`
       // fields so consumers can apply their own escaping policy.
-      description: `${amount} of ${safeText(tokenLabel)} on ${network} via ${safeText(transferMethod)}${approvalTag}`
+      description: `${amount} of ${safeText(tokenLabel)} on ${chain2} via ${safeText(transferMethod)}${approvalTag}`
     };
   });
   const chosen = accepts.find((a3) => a3.preferred);
@@ -47965,7 +47867,7 @@ async function quoteX402(args) {
   if (chosen) {
     const safeTokenLabel = safeText(chosen.tokenName) || chosen.asset;
     const safeMethod = safeText(chosen.transferMethod);
-    summary = `Endpoint offers ${accepts.length} payment option(s). Default route: ${chosen.amount} of ${safeTokenLabel} on ${chosen.network} via ${safeMethod}${chosen.requiresApproval ? " (requires one-time Permit2 approval)" : " (gasless)"}.`;
+    summary = `Endpoint offers ${accepts.length} payment option(s). Default route: ${chosen.amount} of ${safeTokenLabel} on ${chosen.chain} via ${safeMethod}${chosen.requiresApproval ? " (requires one-time Permit2 approval)" : " (gasless)"}.`;
     nextAction = `Show these payment options to the user and let them pick one. Then call x402_request with this url${requestShapeHint}, maxPaymentAtomic set to the picked option's amount, and preferAsset set to its asset contract.`;
   } else if (accepts.length > 0) {
     summary = `Endpoint offers ${accepts.length} payment option(s), but none are supported by this client.`;
@@ -47996,9 +47898,6 @@ var import_zod18 = require("zod");
 init_dist();
 init_dist4();
 var ActionProvider = class {
-  supportsChain(_chainId) {
-    return true;
-  }
 };
 var ActionRegistry = class {
   providers = [];
@@ -48149,13 +48048,21 @@ var TransferActionProvider = class extends ActionProvider {
         )
       }),
       invoke: async (_ctx, input2) => {
+        let chain2;
+        try {
+          chain2 = resolveChain(input2.chain);
+        } catch (err) {
+          const classified = tryClassifyError(err);
+          if (!classified) throw err;
+          return { success: false, code: classified.code, message: classified.message };
+        }
         const wallet = this.walletContext.activeWallet();
         const executor = new TransferExecutor({
           wallet,
           swapClient: this.swapClient
         });
         const result = await executor.execute({
-          chain: input2.chain,
+          chain: chain2,
           to: input2.to,
           amount: input2.amount,
           tokenAddress: input2.tokenAddress,
@@ -48517,7 +48424,7 @@ var AlertActionProvider = class extends ActionProvider {
           condition: input2.condition,
           targetPrice: input2.targetPrice
         });
-        const label = input2.tokenAddress ? `${input2.tokenAddress} on ${chainKey}` : `${requireChain(chainKey).symbol} on ${chainKey}`;
+        const label = input2.tokenAddress ? `${input2.tokenAddress} on ${chainKey}` : `${chainOf(chainKey).symbol} on ${chainKey}`;
         return {
           id: alert.id,
           message: `Alert created: notify when ${label} goes ${input2.condition} $${input2.targetPrice}`
@@ -48534,7 +48441,8 @@ var AlertActionProvider = class extends ActionProvider {
       }),
       invoke: async (_ctx, input2) => {
         const alerts = input2.activeOnly ? await this.alertStore.getActive() : await this.alertStore.list();
-        return { alerts, count: alerts.length };
+        const invalid = await this.alertStore.listInvalid();
+        return { alerts, count: alerts.length, invalid };
       }
     };
   }
@@ -48619,7 +48527,10 @@ var AgentWalletActionProvider = class extends ActionProvider {
       schema: import_zod9.z.object({}),
       invoke: async () => {
         const wallet = this.requireWallet();
-        const addresses = await wallet.getAddresses();
+        const addresses = (await wallet.getAddresses()).map((a3) => ({
+          address: a3.address,
+          chain: a3.chainKey
+        }));
         return { addresses, count: addresses.length };
       }
     };
@@ -48707,7 +48618,7 @@ var TokenActionProvider = class extends ActionProvider {
       invoke: async (_ctx, input2) => {
         const wallet = this.walletContext.activeWallet();
         const chainKey = resolveChain(input2.chain);
-        const chain2 = requireChain(chainKey);
+        const chain2 = chainOf(chainKey);
         if (chain2.namespace !== "eip155") {
           throw new WalletError(
             "CHAIN_UNSUPPORTED",
@@ -48737,7 +48648,7 @@ var TokenActionProvider = class extends ActionProvider {
       invoke: async (_ctx, input2) => {
         const wallet = this.walletContext.activeWallet();
         const chainKey = resolveChain(input2.chain);
-        const chain2 = requireChain(chainKey);
+        const chain2 = chainOf(chainKey);
         if (chain2.namespace !== "eip155") {
           throw new WalletError(
             "CHAIN_UNSUPPORTED",
@@ -49200,14 +49111,13 @@ var OnrampActionProvider = class extends ActionProvider {
       invoke: async (_ctx, input2) => {
         const signer = this.walletContext.activeWallet();
         const { chainKey } = resolveAsset(input2.chain);
-        const chainDef = requireChain(chainKey);
+        const chainDef = chainOf(chainKey);
         if (chainDef.namespace !== "eip155") {
           throw new TransferError(
             "CHAIN_UNSUPPORTED",
             `confirm_offramp_transfer is EVM-only. ${chainKey} is not supported.`
           );
         }
-        const caip2 = `eip155:${chainDef.chainId}`;
         const decimals = validateOfframpInput(input2, chainKey, chainDef.decimals);
         if (this.priceLookup) {
           const cap = await checkOfframpUsdCap(
@@ -49232,7 +49142,7 @@ var OnrampActionProvider = class extends ActionProvider {
           hash = pending.hash;
         } else {
           hash = await signer.sendTransaction({
-            chainId: caip2,
+            chainKey,
             to: input2.depositAddress,
             data: "0x",
             value: "0x" + BigInt(atomic).toString(16)
@@ -49304,6 +49214,10 @@ var AutomateActionProvider = class extends ActionProvider {
           };
         }
         const chainKey = resolveChain(input2.chain);
+        const unsupported = swapSourceUnsupportedReason(chainKey);
+        if (unsupported) {
+          return { success: false, code: "CHAIN_UNSUPPORTED", message: unsupported };
+        }
         const record2 = await this.automationStore.create({
           type: input2.type,
           fromToken: input2.fromToken,
@@ -49329,7 +49243,8 @@ var AutomateActionProvider = class extends ActionProvider {
       invoke: async (_ctx, input2) => {
         const all = await this.automationStore.list();
         const automations = input2.activeOnly ? all.filter((a3) => a3.active) : all;
-        return { success: true, count: automations.length, automations };
+        const invalid = await this.automationStore.listInvalid();
+        return { success: true, count: automations.length, automations, invalid };
       }
     };
   }
@@ -49478,7 +49393,7 @@ var X402ActionProvider = class extends ActionProvider {
           "When true (default), silently grants an UNLIMITED Permit2 allowance if the endpoint requires it \u2014 DANGEROUS, see SAFETY in the action description. Defaults true because MCP agents cannot interact with a prompt, but you MUST consult the user before relying on this on any endpoint you have not paid before. Set to false to surface code: 'PERMIT2_APPROVAL_REQUIRED' instead and route approval out-of-band."
         ),
         preferNetwork: import_zod14.z.string().optional().describe(
-          `Optional override: restrict payment to this network when the endpoint offers multiple. Accepts either CAIP-2 ("eip155:8453") or a chain key ("base"). Case-insensitive. Use this when the user has a balance on a specific chain \u2014 without it, the picker chooses based on transfer-method preference (EIP-3009 over Permit2), which can land on a chain where the wallet has no funds. If no offered entry matches, the call returns code: 'NO_MATCHING_ROUTE' with the list of offered networks so you can re-ask the user.`
+          'Optional override: restrict payment to this chain when the endpoint offers multiple. Pass the `chain` of a quoted option ("base"); other chain forms ("eip155:8453", "8453") are resolved too. Use this when the user has a balance on a specific chain \u2014 without it, the picker chooses based on transfer-method preference (EIP-3009 over Permit2), which can land on a chain where the wallet has no funds. If no offered entry matches, the call returns code: \'NO_MATCHING_ROUTE\' with the list of offered networks so you can re-ask the user.'
         ),
         preferMethod: import_zod14.z.string().optional().describe(
           `Optional override: restrict payment to this transfer method ("eip3009", "permit2", or "permit2-exact"). Case-insensitive. Use this to force the gasless route (eip3009) or to insist on a specific Permit2 variant. If no offered entry matches, the call returns code: 'NO_MATCHING_ROUTE'.`
@@ -49495,7 +49410,7 @@ var X402ActionProvider = class extends ActionProvider {
             method: input2.method,
             body: input2.body,
             maxPaymentAtomic: input2.maxPaymentAtomic,
-            preferNetwork: input2.preferNetwork,
+            preferNetwork: input2.preferNetwork !== void 0 ? resolveChain(input2.preferNetwork) : void 0,
             preferMethod: input2.preferMethod,
             preferAsset: input2.preferAsset,
             provider,
@@ -49515,7 +49430,7 @@ var X402ActionProvider = class extends ActionProvider {
             content: result.content,
             payment: result.payment,
             approval: result.approval,
-            summary: result.payment ? `Paid ${result.payment.amount} ${result.payment.tokenName} on ${result.payment.network} \u2192 ${preview}` : "Request succeeded without payment."
+            summary: result.payment ? `Paid ${result.payment.amount} ${result.payment.tokenName} on ${result.payment.chain} \u2192 ${preview}` : "Request succeeded without payment."
           };
         } catch (err) {
           if (err instanceof X402Error) {
@@ -49558,7 +49473,10 @@ var WalletModeActionProvider = class extends ActionProvider {
    * emits a single text block with the JSON snapshot.
    */
   snapshotResponse(snapshot) {
-    const textPayload = snapshot.pairing ? { ...snapshot, pairing: { ...snapshot.pairing, qrCodeImageUrl: void 0 } } : snapshot;
+    const textPayload = {
+      ...snapshot.pairing ? { ...snapshot, pairing: { ...snapshot.pairing, qrCodeImageUrl: void 0 } } : snapshot,
+      twakHome: twakHome()
+    };
     const content = [{ type: "text", text: JSON.stringify(textPayload, null, 2) }];
     if (snapshot.pairing?.qrCodeImageUrl) {
       const match = snapshot.pairing.qrCodeImageUrl.match(/^data:(image\/[^;]+);base64,(.+)$/);
@@ -49598,7 +49516,7 @@ var WalletModeActionProvider = class extends ActionProvider {
   getWalletStatus() {
     return {
       name: "get_wallet_status",
-      description: 'Returns the current wallet binding for this MCP server session: state ("unbound" | "local" | "wc-pairing" | "wc-connected"), wallet type (when bound), peer name (when wc-connected), and pairing data (URI / deep link / QR code, when state="wc-pairing"). When state="wc-pairing", the response includes an inline QR-code image (MCP image content), a mobile deep link (`pairing.deepLink`) for users on their phone, and the raw `pairing.uri` as a copyable string for advanced users. Poll this after switch_wallet_mode({mode: "walletconnect"}) until state transitions to "wc-connected"; that\'s when signing actions become usable. If the user asks to see the QR code again (e.g. "show me the QR", "I can\'t see it"), call this action again \u2014 every call while state="wc-pairing" re-emits the inline QR image. Do NOT try to render the QR yourself from the URI or the response JSON.',
+      description: 'Returns the current wallet binding for this MCP server session: state ("unbound" | "local" | "wc-pairing" | "wc-connected"), wallet type (when bound), peer name (when wc-connected), pairing data (URI / deep link / QR code, when state="wc-pairing"), and `twakHome`: the folder this server keeps its files in (wallet, WalletConnect session, credentials), set from TWAK_HOME when the server started (default ~/.twak). When state="wc-pairing", the response includes an inline QR-code image (MCP image content), a mobile deep link (`pairing.deepLink`) for users on their phone, and the raw `pairing.uri` as a copyable string for advanced users. Poll this after switch_wallet_mode({mode: "walletconnect"}) until state transitions to "wc-connected"; that\'s when signing actions become usable. If the user asks to see the QR code again (e.g. "show me the QR", "I can\'t see it"), call this action again \u2014 every call while state="wc-pairing" re-emits the inline QR image. Do NOT try to render the QR yourself from the URI or the response JSON.',
       schema: import_zod15.z.object({}),
       invoke: async () => this.snapshotResponse(this.walletContext.snapshot())
     };
@@ -49735,9 +49653,12 @@ var Erc8004ActionProvider = class extends ActionProvider {
     if (!this.blockchainClient) {
       throw new WalletError("WALLET_NOT_FOUND", "Chain client not available");
     }
-    return new Erc8004Operations(resolveErc8004Contract(this.blockchainClient, chainInput), {
-      signer
-    });
+    return new Erc8004Operations(
+      resolveErc8004Contract(this.blockchainClient, resolveChain(chainInput)),
+      {
+        signer
+      }
+    );
   }
 };
 var jobIdSchema = import_zod17.z.string().regex(/^\d+$/, "jobId must be a decimal integer string.").describe("Numeric jobId as a decimal string.");
@@ -50121,14 +50042,14 @@ var Erc8183ActionProvider = class extends ActionProvider {
       throw new WalletError("WALLET_NOT_FOUND", "Chain client not available");
     }
     const client = this.blockchainClient;
-    return new Erc8183Operations(resolveErc8183Contracts(client, chainInput), {
+    return new Erc8183Operations(resolveErc8183Contracts(client, resolveChain(chainInput)), {
       signer,
       erc20At: (token, chainKey) => erc20.using(client).withAddress(token, chainKey),
       policyAt: (address, chainKey) => erc8183Policy.using(client).withAddress(address, chainKey)
     });
   }
 };
-var CHAIN = "bsc";
+var CHAIN = knownChainKey("bsc");
 function toIso2(deadline) {
   return new Date(Number(deadline) * 1e3).toISOString();
 }
@@ -53626,7 +53547,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve4) => setTimeout(resolve4, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -53643,7 +53564,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -53721,7 +53642,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve4(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -53982,12 +53903,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve4, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -54857,12 +54778,12 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve4();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve4);
       }
     });
   }
@@ -55009,7 +54930,7 @@ var TwakRestServer = class {
     };
   }
   start() {
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve4, reject) => {
       const server = (0, import_http.createServer)((req, res) => this.handleRequest(req, res));
       this.httpServer = server;
       server.on("error", (err) => {
@@ -55029,20 +54950,20 @@ var TwakRestServer = class {
         } else {
           console.error("WARNING: No API key configured \u2014 REST server is unauthenticated");
         }
-        resolve2();
+        resolve4();
       });
     });
   }
   stop() {
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       if (this.httpServer?.listening) {
         this.httpServer.close(() => {
           this.httpServer = null;
-          resolve2();
+          resolve4();
         });
       } else {
         this.httpServer = null;
-        resolve2();
+        resolve4();
       }
     });
   }
@@ -55271,7 +55192,7 @@ function registerServeCommand(program3) {
     }
     const walletLoader = new AgentWalletLoader({
       walletExists: () => new WalletConfigStore().exists(),
-      resolvePassword: async () => opts.password || process.env.TWAK_WALLET_PASSWORD || await new KeychainManager().getWalletPassword() || void 0,
+      resolvePassword: async () => await findWalletPassword(opts) ?? void 0,
       open: (password3) => AgentWalletProvider.fromStorage(password3),
       onLoaded: (agentWallet) => {
         if (autoLockMinutes) {
@@ -55731,7 +55652,7 @@ ${url}`);
       } catch {
         throw new TransferError("VALIDATION_ERROR", `Invalid asset ID: ${opts.asset}`);
       }
-      const chainKey = coinTypeToChainKey(coinId);
+      const chainKey = mainnetChainKeyForCoinId(coinId);
       if (!chainKey) {
         throw new TransferError(
           "CHAIN_UNSUPPORTED",
@@ -55797,7 +55718,7 @@ ${url}`);
           decimals,
           memo: opts.memo,
           // Mainnet by construction — onramp has no --chain input and derives
-          // chainKey from the asset's coinId via the CHAINS-only resolver.
+          // chainKey from the asset's coinId via mainnetChainKeyForCoinId.
           chainKey
         });
       } catch (err) {
@@ -55894,20 +55815,9 @@ function registerAutomateCommand(program3) {
       if (isNaN(amount) || amount <= 0) {
         throw new AutomationError("VALIDATION_ERROR", "Amount must be a positive number");
       }
-      if (!isChainSupported(opts.chain)) {
-        throw new AutomationError(
-          "CHAIN_UNSUPPORTED",
-          `Unsupported chain: ${opts.chain}. Run 'twak chains' to list supported chains.`
-        );
-      }
-      const SWAP_SUPPORTED_NAMESPACES = ["eip155", "solana"];
-      const chainInfo = getChainById(opts.chain);
-      if (chainInfo && !SWAP_SUPPORTED_NAMESPACES.includes(chainInfo.namespace)) {
-        throw new AutomationError(
-          "CHAIN_UNSUPPORTED",
-          `${chainInfo.name} automations are not supported. Use an EVM chain or Solana.`
-        );
-      }
+      const chain2 = resolveChain(opts.chain);
+      const unsupported = swapSourceUnsupportedReason(chain2);
+      if (unsupported) throw new AutomationError("CHAIN_UNSUPPORTED", unsupported);
       let intervalMs;
       if (opts.interval) {
         const parsed = parseInterval2(opts.interval);
@@ -55939,7 +55849,7 @@ function registerAutomateCommand(program3) {
         type: opts.interval ? "dca" : "limit",
         fromToken: opts.from,
         toToken: opts.to,
-        chain: opts.chain,
+        chain: chain2,
         amount: opts.amount,
         intervalMs,
         targetPrice: opts.price ? parseFloat(opts.price) : void 0,
@@ -55951,11 +55861,11 @@ function registerAutomateCommand(program3) {
       success("Automation created!");
       if (opts.interval && intervalMs) {
         info(
-          `DCA: ${opts.amount} ${opts.from} \u2192 ${opts.to} every ${formatInterval(intervalMs)} on ${opts.chain}`
+          `DCA: ${opts.amount} ${opts.from} \u2192 ${opts.to} every ${formatInterval(intervalMs)} on ${chain2}`
         );
       } else {
         info(
-          `Limit: swap ${opts.amount} ${opts.from} \u2192 ${opts.to} when price ${opts.condition} $${opts.price} on ${opts.chain}`
+          `Limit: swap ${opts.amount} ${opts.from} \u2192 ${opts.to} when price ${opts.condition} $${opts.price} on ${chain2}`
         );
       }
       output(record2, opts.json);
@@ -55967,6 +55877,9 @@ function registerAutomateCommand(program3) {
     try {
       const store = new AutomationStore();
       const records = await store.list();
+      for (const r3 of await store.listInvalid()) {
+        warn(`Automation ${r3.id} is invalid: ${r3.error} (stored chain "${r3.chain}")`);
+      }
       if (opts.json) {
         const enriched = records.map((r3) => {
           const nextRunAt = r3.type === "dca" && r3.intervalMs ? r3.lastRunAt ? new Date(new Date(r3.lastRunAt).getTime() + r3.intervalMs).toISOString() : (/* @__PURE__ */ new Date()).toISOString() : null;
@@ -56056,32 +55969,30 @@ function makeReadlineConfirm() {
   return async (k4) => {
     const readline = await import("readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       rl.question(
         `
-Sign payment authorization: ${k4.amount} (atomic) ${k4.tokenName} on ${k4.network} (${k4.chainKey})
+Sign payment authorization: ${k4.amount} (atomic) ${k4.tokenName} on ${k4.chainKey}
 Token contract: ${k4.asset}
 Recipient:      ${k4.payTo}
 Confirm? [y/N] `,
         (a3) => {
           rl.close();
-          resolve2(a3.toLowerCase() === "y");
+          resolve4(a3.toLowerCase() === "y");
         }
       );
     });
   };
 }
 async function autoConfirm(k4) {
-  info(
-    `x402: paying ${k4.amount} ${k4.tokenName} (${k4.asset}) on ${k4.network} (${k4.chainKey}) \u2192 ${k4.payTo}`
-  );
+  info(`x402: paying ${k4.amount} ${k4.tokenName} (${k4.asset}) on ${k4.chainKey} \u2192 ${k4.payTo}`);
   return true;
 }
 function makeReadlineApprovalConfirm() {
   return async (c3) => {
     const readline = await import("readline");
     const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-    return new Promise((resolve2) => {
+    return new Promise((resolve4) => {
       rl.question(
         `
 This token has not yet been approved for Permit2 on ${c3.chain} (chainId ${c3.chainId}).
@@ -56098,7 +56009,7 @@ the approval alone does not move funds. Revokable anytime via
 Approve unlimited Permit2 allowance? [y/N] `,
         (a3) => {
           rl.close();
-          resolve2(a3.toLowerCase() === "y");
+          resolve4(a3.toLowerCase() === "y");
         }
       );
     });
@@ -56108,18 +56019,8 @@ async function autoApproveConfirm(c3) {
   warn(`x402: auto-approving Permit2 unlimited allowance for ${c3.token} on ${c3.chain}`);
   return true;
 }
-function supportedChainName(network) {
-  if (network.startsWith("eip155:")) {
-    return getChainByEvmId(network.slice("eip155:".length))?.name ?? null;
-  }
-  return getChainById(network)?.name ?? null;
-}
-function filterAndSortAccepts(accepts) {
-  const supported = accepts.flatMap((a3) => {
-    const chainName = supportedChainName(a3.network);
-    return chainName ? [{ ...a3, chainName }] : [];
-  });
-  return supported.sort((a3, b3) => Number(b3.preferred) - Number(a3.preferred));
+function sortAccepts(accepts) {
+  return accepts.map((a3) => ({ ...a3, chainName: chainOf(a3.chain).name })).sort((a3, b3) => Number(b3.preferred) - Number(a3.preferred));
 }
 function safeTokenName(s2) {
   return s2.replace(/[\x00-\x1f\x7f]/g, "");
@@ -56166,7 +56067,7 @@ function registerX402Command(program3) {
     'Maximum payment to auto-approve, in atomic units (e.g. "10000" = 0.01 USDC at 6dp)'
   ).option(
     "--prefer-network <network>",
-    'Restrict route to this chain (e.g. "base", "bsc", or CAIP "eip155:8453"). AND-combined with --prefer-method/--prefer-asset.'
+    'Restrict route to this chain (e.g. "base", "bsc", or any chain form such as "eip155:8453"). AND-combined with --prefer-method/--prefer-asset.'
   ).option(
     "--prefer-method <method>",
     'Restrict route to this transfer method ("eip3009" or "permit2-exact").'
@@ -56189,7 +56090,7 @@ function registerX402Command(program3) {
         method: opts.method,
         body: opts.body,
         maxPaymentAtomic: opts.maxPayment,
-        preferNetwork: opts.preferNetwork,
+        preferNetwork: opts.preferNetwork !== void 0 ? resolveChain(opts.preferNetwork) : void 0,
         preferMethod: opts.preferMethod,
         preferAsset: opts.preferAsset,
         provider,
@@ -56224,7 +56125,7 @@ function registerX402Command(program3) {
         process.exitCode = 1;
         return;
       }
-      const sorted = filterAndSortAccepts(result.accepts);
+      const sorted = sortAccepts(result.accepts);
       const hasSignableRoute = sorted.some((r3) => r3.preferred);
       const shQuote = (s2) => `'${s2.replace(/'/g, `'\\''`)}'`;
       const cliCommand = (amount) => {
@@ -56305,14 +56206,15 @@ function registerX402Command(program3) {
 
 // src/analytics.ts
 var fs9 = __toESM(require("fs"));
-var os4 = __toESM(require("os"));
-var path6 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var path12 = __toESM(require("path"));
 var crypto8 = __toESM(require("crypto"));
+init_dist();
 
 // package.json
 var package_default = {
   name: "@trustwallet/cli",
-  version: "0.23.0",
+  version: "0.24.1",
   description: "TWAK CLI \u2014 command-line interface for Trust Wallet Agent Kit",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -56389,10 +56291,9 @@ try {
 } catch (_e6) {
 }
 var AMPLITUDE_API_KEY = process.env.AMPLITUDE_API_KEY || "__AMPLITUDE_API_KEY__";
-var CONFIG_DIR = path6.join(os4.homedir(), ".twak");
-var ID_FILE = path6.join(CONFIG_DIR, "analytics-id");
-var OPT_IN_FILE = path6.join(CONFIG_DIR, "telemetry-on");
-var OPT_OUT_FILE = path6.join(CONFIG_DIR, "telemetry-off");
+var idFile = () => path12.join(twakHome(), "analytics-id");
+var optInFile = () => path12.join(twakHome(), "telemetry-on");
+var optOutFile = () => path12.join(twakHome(), "telemetry-off");
 var initialized2 = false;
 function isOptedOut() {
   if (process.argv.includes("--no-analytics")) return true;
@@ -56400,31 +56301,31 @@ function isOptedOut() {
   if (env === "off" || env === "0" || env === "false") return true;
   if (env === "on" || env === "1" || env === "true") return false;
   try {
-    if (fs9.existsSync(OPT_OUT_FILE)) return true;
-    return !fs9.existsSync(OPT_IN_FILE);
+    if (fs9.existsSync(optOutFile())) return true;
+    return !fs9.existsSync(optInFile());
   } catch (_e6) {
     return true;
   }
 }
 function setOptOut2(optOut) {
-  fs9.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs9.mkdirSync(twakHome(), { recursive: true });
   if (optOut) {
-    if (fs9.existsSync(OPT_IN_FILE)) fs9.unlinkSync(OPT_IN_FILE);
-    fs9.writeFileSync(OPT_OUT_FILE, "");
+    if (fs9.existsSync(optInFile())) fs9.unlinkSync(optInFile());
+    fs9.writeFileSync(optOutFile(), "");
   } else {
-    fs9.writeFileSync(OPT_IN_FILE, "");
-    if (fs9.existsSync(OPT_OUT_FILE)) fs9.unlinkSync(OPT_OUT_FILE);
+    fs9.writeFileSync(optInFile(), "");
+    if (fs9.existsSync(optOutFile())) fs9.unlinkSync(optOutFile());
   }
 }
 function getUserId() {
   try {
-    if (fs9.existsSync(ID_FILE)) return fs9.readFileSync(ID_FILE, "utf-8").trim();
+    if (fs9.existsSync(idFile())) return fs9.readFileSync(idFile(), "utf-8").trim();
   } catch (_e6) {
   }
   const id = crypto8.randomUUID();
   try {
-    fs9.mkdirSync(CONFIG_DIR, { recursive: true });
-    fs9.writeFileSync(ID_FILE, id);
+    fs9.mkdirSync(twakHome(), { recursive: true });
+    fs9.writeFileSync(idFile(), id);
   } catch (_e6) {
   }
   return id;
@@ -56441,13 +56342,17 @@ function initAnalytics() {
 async function trackEvent(eventName, properties = {}) {
   if (!initialized2 || isOptedOut()) return;
   const globalProps = {
-    os_platform: os4.platform(),
-    os_arch: os4.arch(),
+    os_platform: os3.platform(),
+    os_arch: os3.arch(),
     node_version: process.version,
     twak_version: package_default.version
   };
   try {
-    const result = track2(eventName, { ...globalProps, ...properties }, { user_id: getUserId() });
+    const result = track2(
+      eventName,
+      { ...globalProps, ...properties },
+      { user_id: getUserId() }
+    );
     await result.promise;
   } catch (_e6) {
   }