@alchemy/cli 0.9.1 → 0.9.3

package/dist/index.js

@@ -5,32 +5,35 @@ import {
   errNotLoggedInForPolicyLookup,
   errSponsorshipNeedsPolicy,
   selectOrCreatePolicy
-} from "./chunk-TTWOBNJP.js";
+} from "./chunk-D2RUM2DD.js";
 import {
   registerAuth
-} from "./chunk-L2WODD2D.js";
+} from "./chunk-L5E7GEUU.js";
 import {
   openBrowser
-} from "./chunk-RGVM5SNE.js";
+} from "./chunk-AMGGO36F.js";
 import {
   SETUP_CAPABILITY_LABELS,
   SETUP_CAPABILITY_ORDER,
   getSetupStatus,
   isSetupComplete,
   shouldRunOnboarding
-} from "./chunk-P56HOTPV.js";
+} from "./chunk-VN5JUWHO.js";
 import {
   isInteractiveAllowed
-} from "./chunk-75ICFV5K.js";
+} from "./chunk-3GBDYROJ.js";
 import {
+  RpcApiError,
   adminClientFromFlags,
   clearSession,
   clientFromFlags,
   createPendingSession,
   fromAdminNetworkId,
   gasManagerClientFromFlags,
+  getGatewayDomain,
   getRPCNetworks,
   getWalletSessionByChain,
+  globalRpcCall,
   hasAuthLoginToken,
   isSessionValid,
   isSolanaNetwork,
@@ -52,14 +55,17 @@ import {
   resolveWalletSession,
   resolveX402Client,
   saveSession,
+  supportedWalletNetworks,
   toAdminNetworkId,
-  updateSession
-} from "./chunk-SIIZGMK5.js";
+  updateSession,
+  validateNetwork,
+  walletNetworkToChain
+} from "./chunk-ANONMDDZ.js";
 import {
   getAvailableUpdate,
   getUpdateStatus,
   printUpdateNotice
-} from "./chunk-AJOLFTCZ.js";
+} from "./chunk-NUSUQI7X.js";
 import {
   bold,
   brand,
@@ -83,7 +89,7 @@ import {
   weiToEth,
   withSpinner,
   yellow
-} from "./chunk-MV7O3XBG.js";
+} from "./chunk-PMNRIXJI.js";
 import {
   KEY_MAP,
   configDir,
@@ -94,7 +100,7 @@ import {
   save,
   toMap,
   validKeys
-} from "./chunk-GDLPBPG3.js";
+} from "./chunk-GLKB4JM7.js";
 import {
   CLIError,
   EXIT_CODES,
@@ -107,6 +113,7 @@ import {
   errNetwork,
   errNoActiveSession,
   errNotFound,
+  errRPC,
   errRateLimited,
   errSessionExpired,
   errSetupRequired,
@@ -129,8 +136,9 @@ import {
   quiet,
   setFlags,
   setNoColor,
+  timeout,
   verbose
-} from "./chunk-OVLQH6KL.js";
+} from "./chunk-CTTW4PA4.js";
 
 // src/index.ts
 import { Command, Help } from "commander";
@@ -577,8 +585,8 @@ function registerConfig(program2) {
           "Interactive policy selection requires an interactive terminal. Pass an ID: `alchemy config set evm-gas-policy-id <id>`."
         );
       }
-      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-4BV5AWVV.js");
-      const { resolveNetwork: resolveNetwork2 } = await import("./resolve-FQ66OWT7.js");
+      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-V6W7CPAO.js");
+      const { resolveNetwork: resolveNetwork2 } = await import("./resolve-REZCFZZ7.js");
       const network = resolveNetwork2(program2);
       await selectOrCreatePolicy2({
         flavor: "sponsorship",
@@ -632,8 +640,8 @@ function registerConfig(program2) {
           "Interactive policy selection requires an interactive terminal. Pass an ID: `alchemy config set solana-fee-policy-id <id>`."
         );
       }
-      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-4BV5AWVV.js");
-      const { resolveSolanaNetwork: resolveSolanaNetwork2 } = await import("./resolve-FQ66OWT7.js");
+      const { selectOrCreatePolicy: selectOrCreatePolicy2 } = await import("./policy-prompt-V6W7CPAO.js");
+      const { resolveSolanaNetwork: resolveSolanaNetwork2 } = await import("./resolve-REZCFZZ7.js");
       const network = resolveSolanaNetwork2(program2);
       await selectOrCreatePolicy2({
         flavor: "solana",
@@ -691,7 +699,7 @@ function registerConfig(program2) {
       printJSON(toMap(cfg));
       return;
     }
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-FQ66OWT7.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-REZCFZZ7.js");
     const validToken = resolveAuthToken2(cfg);
     const authStatus = cfg.auth_token ? validToken ? `${green("\u2713")} authenticated${cfg.auth_token_expires_at ? ` ${dim(`(expires ${cfg.auth_token_expires_at})`)}` : ""}` : `${yellow("\u25C6")} expired${cfg.auth_token_expires_at ? ` ${dim(`(${cfg.auth_token_expires_at})`)}` : ""}` : dim("(not set) \u2014 run 'alchemy auth' to log in");
     const pairs = [
@@ -1924,10 +1932,10 @@ function createInterruptibleDelay(ms, signal) {
   }
   return new Promise((resolve, reject) => {
     const onAbort = () => {
-      clearTimeout(timeout);
+      clearTimeout(timeout2);
       reject(new WalletConnectInterruptedError());
     };
-    const timeout = setTimeout(() => {
+    const timeout2 = setTimeout(() => {
       signal.removeEventListener("abort", onAbort);
       resolve();
     }, ms);
@@ -2568,25 +2576,25 @@ function printCrossModeHintAfterLocal(chain) {
 async function runConnectFlow(program2, opts) {
   const force = Boolean(opts.force);
   const importPath = opts.import;
-  let mode2;
+  let mode;
   if (opts.mode === "session" || opts.mode === "local") {
-    mode2 = opts.mode;
+    mode = opts.mode;
   } else if (opts.mode !== void 0) {
     throw errInvalidArgs("`--mode` must be 'session' or 'local'.");
   }
   if (opts.instanceName !== void 0) {
-    if (mode2 === "local") {
+    if (mode === "local") {
       throw errInvalidArgs("`--instance-name` is only valid with `--mode session`.");
     }
-    mode2 = "session";
+    mode = "session";
   }
   if (importPath) {
-    if (mode2 === "session") {
+    if (mode === "session") {
       throw errInvalidArgs("`--import` is only valid with `--mode local`.");
     }
-    mode2 = "local";
+    mode = "local";
   }
-  if (!mode2) {
+  if (!mode) {
     if (!isInteractiveAllowed(program2)) {
       throw errInvalidArgs(
         "Specify `--mode <session|local>` in non-interactive mode."
@@ -2602,9 +2610,9 @@ async function runConnectFlow(program2, opts) {
       cancelMessage: "Wallet connect cancelled."
     });
     if (choice === null) throw new WalletConnectInterruptedError();
-    mode2 = choice;
+    mode = choice;
   }
-  if (mode2 === "session") {
+  if (mode === "session") {
     await runSessionConnect({
       program: program2,
       force,
@@ -3097,15 +3105,15 @@ async function requestJSON(url, options) {
 async function callApiData(apiKey, path, options = {}) {
   if (!apiKey) throw errAuthRequired();
   const override = parseBaseURLOverride(DATA_API_BASE_URL_ENV);
-  const base2 = override ? new URL(`/data/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/data/v1/${apiKey}/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = override ? new URL(`/data/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/data/v1/${apiKey}/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, { ...options, path });
 }
 async function callApiPrices(apiKey, path, options = {}) {
   if (!apiKey) throw errAuthRequired();
   const override = parseBaseURLOverride(PRICES_API_BASE_URL_ENV);
-  const base2 = override ? new URL(`/prices/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/prices/v1/${apiKey}/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = override ? new URL(`/prices/v1/${apiKey}/`, override) : new URL(`https://api.g.${getBaseDomain()}/prices/v1/${apiKey}/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, { ...options, path });
 }
 async function callNotify(token, path, options = {}) {
@@ -3114,8 +3122,8 @@ async function callNotify(token, path, options = {}) {
       "Webhook API key required. Set ALCHEMY_WEBHOOK_API_KEY (or ALCHEMY_NOTIFY_AUTH_TOKEN) or pass --webhook-api-key."
     );
   }
-  const base2 = new URL(`https://dashboard.${getBaseDomain()}/api/`);
-  const url = withQuery(new URL(path.replace(/^\//, ""), base2), options.query);
+  const base = new URL(`https://dashboard.${getBaseDomain()}/api/`);
+  const url = withQuery(new URL(path.replace(/^\//, ""), base), options.query);
   return requestJSON(url, {
     ...options,
     path,
@@ -4267,51 +4275,10 @@ import { createSmartWalletClient } from "@alchemy/wallet-apis";
 import { privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
 // src/lib/chains.ts
-import * as viemChains from "viem/chains";
-var NETWORK_TO_CHAIN = {
-  "eth-mainnet": viemChains.mainnet,
-  "eth-sepolia": viemChains.sepolia,
-  "eth-holesky": viemChains.holesky,
-  "base-mainnet": viemChains.base,
-  "base-sepolia": viemChains.baseSepolia,
-  "arb-mainnet": viemChains.arbitrum,
-  "arb-sepolia": viemChains.arbitrumSepolia,
-  "opt-mainnet": viemChains.optimism,
-  "opt-sepolia": viemChains.optimismSepolia,
-  "polygon-mainnet": viemChains.polygon,
-  "polygon-amoy": viemChains.polygonAmoy,
-  "zksync-mainnet": viemChains.zksync,
-  "zksync-sepolia": viemChains.zksyncSepoliaTestnet,
-  "avax-mainnet": viemChains.avalanche,
-  "avax-fuji": viemChains.avalancheFuji,
-  "bnb-mainnet": viemChains.bsc,
-  "bnb-testnet": viemChains.bscTestnet,
-  "linea-mainnet": viemChains.linea,
-  "linea-sepolia": viemChains.lineaSepolia,
-  "scroll-mainnet": viemChains.scroll,
-  "scroll-sepolia": viemChains.scrollSepolia,
-  "blast-mainnet": viemChains.blast,
-  "blast-sepolia": viemChains.blastSepolia,
-  "zora-mainnet": viemChains.zora,
-  "zora-sepolia": viemChains.zoraSepolia,
-  "celo-mainnet": viemChains.celo,
-  "gnosis-mainnet": viemChains.gnosis,
-  "mantle-mainnet": viemChains.mantle,
-  "worldchain-mainnet": viemChains.worldchain,
-  "shape-mainnet": viemChains.shape,
-  "unichain-mainnet": viemChains.unichain,
-  "unichain-sepolia": viemChains.unichainSepolia,
-  "ink-mainnet": viemChains.ink,
-  "ink-sepolia": viemChains.inkSepolia,
-  "soneium-mainnet": viemChains.soneium,
-  "frax-mainnet": viemChains.fraxtal,
-  "mode-mainnet": viemChains.mode,
-  "berachain-mainnet": viemChains.berachain
-};
 function networkToChain(network) {
-  const chain = NETWORK_TO_CHAIN[network];
+  const chain = walletNetworkToChain(network);
   if (!chain) {
-    const supported = Object.keys(NETWORK_TO_CHAIN).sort().join(", ");
+    const supported = supportedWalletNetworks().join(", ");
     throw errInvalidArgs(
       `Network "${network}" is not supported for wallet operations. Supported networks: ${supported}`
     );
@@ -5102,6 +5069,517 @@ function formatError(error) {
   }
 }
 
+// ../../packages/sdk/dist/data/index.js
+var DEFAULT_DATA_TIMEOUT_MS = 3e4;
+var DEFAULT_BREADCRUMB_HEADER = "alchemy-sdk";
+var DataApiError = class extends Error {
+  status;
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+    this.name = "DataApiError";
+  }
+};
+async function dataGet(baseUrl, apiKey, path, params, options = {}) {
+  const url = new URL(`${baseUrl}/${apiKey}${path}`);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0)
+        continue;
+      if (Array.isArray(value)) {
+        for (const item of value)
+          url.searchParams.append(key, item);
+      } else {
+        url.searchParams.set(key, value);
+      }
+    }
+  }
+  const resp = await dataFetch(url.toString(), "GET", void 0, options);
+  return resp.json();
+}
+async function dataPost(baseUrl, apiKey, path, body, options = {}) {
+  const resp = await dataFetch(`${baseUrl}/${apiKey}${path}`, "POST", body, options);
+  return resp.json();
+}
+function nftBaseUrl(network, options = {}) {
+  validateNetwork(network);
+  return `https://${network}.${getGatewayDomain(options)}/nft/v3`;
+}
+function pricesBaseUrl(options = {}) {
+  return `https://api.${getGatewayDomain(options)}/prices/v1`;
+}
+function portfolioBaseUrl(options = {}) {
+  return `https://api.${getGatewayDomain(options)}/data/v1`;
+}
+function createAlchemyDataClient(apiKey, options = {}) {
+  return new AlchemyDataClient(apiKey, options);
+}
+var AlchemyDataClient = class {
+  apiKey;
+  options;
+  nft;
+  prices;
+  portfolio;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+    this.nft = new NftApiClient(apiKey, options);
+    this.prices = new PricesApiClient(apiKey, options);
+    this.portfolio = new PortfolioApiClient(apiKey, options);
+  }
+};
+var NftApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getNFTsForOwner(network, params) {
+    return this.get(network, "/getNFTsForOwner", params);
+  }
+  getNFTsForContract(network, params) {
+    return this.get(network, "/getNFTsForContract", params);
+  }
+  getNFTMetadata(network, params) {
+    return this.get(network, "/getNFTMetadata", params);
+  }
+  getNFTMetadataBatch(network, body) {
+    return this.post(network, "/getNFTMetadataBatch", body);
+  }
+  getContractMetadata(network, params) {
+    return this.get(network, "/getContractMetadata", params);
+  }
+  getOwnersForNFT(network, params) {
+    return this.get(network, "/getOwnersForNFT", params);
+  }
+  getOwnersForContract(network, params) {
+    return this.get(network, "/getOwnersForContract", params);
+  }
+  getFloorPrice(network, params) {
+    return this.get(network, "/getFloorPrice", params);
+  }
+  isSpamContract(network, params) {
+    return this.get(network, "/isSpamContract", params);
+  }
+  searchContractMetadata(network, params) {
+    return this.get(network, "/searchContractMetadata", params);
+  }
+  getNFTSales(network, params) {
+    return this.get(network, "/getNFTSales", params);
+  }
+  getContractsForOwner(network, params) {
+    return this.get(network, "/getContractsForOwner", params);
+  }
+  getNFTsForCollection(network, params) {
+    return this.get(network, "/getNFTsForCollection", params);
+  }
+  getCollectionMetadata(network, params) {
+    return this.get(network, "/getCollectionMetadata", params);
+  }
+  getContractMetadataBatch(network, body) {
+    return this.post(network, "/getContractMetadataBatch", body);
+  }
+  getSpamContracts(network) {
+    return this.get(network, "/getSpamContracts", {});
+  }
+  isAirdropNFT(network, params) {
+    return this.get(network, "/isAirdropNFT", params);
+  }
+  summarizeNFTAttributes(network, params) {
+    return this.get(network, "/summarizeNFTAttributes", params);
+  }
+  isHolderOfContract(network, params) {
+    return this.get(network, "/isHolderOfContract", params);
+  }
+  computeRarity(network, params) {
+    return this.get(network, "/computeRarity", params);
+  }
+  getCollectionsForOwner(network, params) {
+    return this.get(network, "/getCollectionsForOwner", params);
+  }
+  get(network, path, params) {
+    return dataGet(nftBaseUrl(network, this.options), this.apiKey, path, params, this.options);
+  }
+  post(network, path, body) {
+    return dataPost(nftBaseUrl(network, this.options), this.apiKey, path, body, this.options);
+  }
+};
+var PricesApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getTokenPricesBySymbol(params) {
+    return dataGet(pricesBaseUrl(this.options), this.apiKey, "/tokens/by-symbol", params, this.options);
+  }
+  getTokenPricesByAddress(body) {
+    return dataPost(pricesBaseUrl(this.options), this.apiKey, "/tokens/by-address", body, this.options);
+  }
+  getHistoricalTokenPrices(body) {
+    return dataPost(pricesBaseUrl(this.options), this.apiKey, "/tokens/historical", body, this.options);
+  }
+};
+var PortfolioApiClient = class {
+  apiKey;
+  options;
+  constructor(apiKey, options = {}) {
+    this.apiKey = apiKey;
+    this.options = options;
+  }
+  getTokensByAddress(body) {
+    return this.post("/assets/tokens/by-address", body);
+  }
+  getTokenBalancesByAddress(body) {
+    return this.post("/assets/tokens/balances/by-address", body);
+  }
+  getNFTsByAddress(body) {
+    return this.post("/assets/nfts/by-address", body);
+  }
+  getNFTContractsByAddress(body) {
+    return this.post("/assets/nfts/contracts/by-address", body);
+  }
+  post(path, body) {
+    return dataPost(portfolioBaseUrl(this.options), this.apiKey, path, body, this.options);
+  }
+};
+async function dataFetch(url, method, body, options) {
+  const fetchFn = options.fetchFn ?? fetch;
+  const resp = await fetchFn(url, {
+    method,
+    headers: {
+      ...body !== void 0 && { "Content-Type": "application/json" },
+      Accept: "application/json",
+      "x-alchemy-client-breadcrumb": options.breadcrumb ?? DEFAULT_BREADCRUMB_HEADER
+    },
+    ...body !== void 0 && { body: JSON.stringify(body) },
+    signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_DATA_TIMEOUT_MS)
+  });
+  if (!resp.ok) {
+    const text = await resp.text().catch(() => "");
+    throw new DataApiError(resp.status, text || `HTTP ${resp.status}`);
+  }
+  return resp;
+}
+
+// ../../packages/sdk/dist/surfaces/index.js
+var RPC_API_SURFACE = [
+  { name: "ethGetBalance", rpcMethod: "eth_getBalance", family: "evm", gateway: "network" },
+  { name: "ethGetBlockByNumber", rpcMethod: "eth_getBlockByNumber", family: "evm", gateway: "network" },
+  { name: "ethGetBlockByHash", rpcMethod: "eth_getBlockByHash", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByHash", rpcMethod: "eth_getTransactionByHash", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionReceipt", rpcMethod: "eth_getTransactionReceipt", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionCount", rpcMethod: "eth_getTransactionCount", family: "evm", gateway: "network" },
+  { name: "ethBlockNumber", rpcMethod: "eth_blockNumber", family: "evm", gateway: "network" },
+  { name: "ethGasPrice", rpcMethod: "eth_gasPrice", family: "evm", gateway: "network" },
+  { name: "ethEstimateGas", rpcMethod: "eth_estimateGas", family: "evm", gateway: "network" },
+  { name: "ethGetCode", rpcMethod: "eth_getCode", family: "evm", gateway: "network" },
+  { name: "ethGetStorageAt", rpcMethod: "eth_getStorageAt", family: "evm", gateway: "network" },
+  { name: "ethGetLogs", rpcMethod: "eth_getLogs", family: "evm", gateway: "network" },
+  { name: "ethChainId", rpcMethod: "eth_chainId", family: "evm", gateway: "network" },
+  { name: "ethFeeHistory", rpcMethod: "eth_feeHistory", family: "evm", gateway: "network" },
+  { name: "ethMaxPriorityFeePerGas", rpcMethod: "eth_maxPriorityFeePerGas", family: "evm", gateway: "network" },
+  { name: "netVersion", rpcMethod: "net_version", family: "evm", gateway: "network" },
+  { name: "web3ClientVersion", rpcMethod: "web3_clientVersion", family: "evm", gateway: "network" },
+  { name: "ethGetBlockTransactionCountByHash", rpcMethod: "eth_getBlockTransactionCountByHash", family: "evm", gateway: "network" },
+  { name: "ethGetBlockTransactionCountByNumber", rpcMethod: "eth_getBlockTransactionCountByNumber", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByBlockHashAndIndex", rpcMethod: "eth_getTransactionByBlockHashAndIndex", family: "evm", gateway: "network" },
+  { name: "ethGetTransactionByBlockNumberAndIndex", rpcMethod: "eth_getTransactionByBlockNumberAndIndex", family: "evm", gateway: "network" },
+  { name: "ethSyncing", rpcMethod: "eth_syncing", family: "evm", gateway: "network" },
+  { name: "ethCallBundle", rpcMethod: "eth_callBundle", family: "evm", gateway: "network" },
+  { name: "ethCallMany", rpcMethod: "eth_callMany", family: "evm", gateway: "network" },
+  { name: "netListening", rpcMethod: "net_listening", family: "evm", gateway: "network" },
+  { name: "web3Sha3", rpcMethod: "web3_sha3", family: "evm", gateway: "network" },
+  { name: "getTokenBalances", rpcMethod: "alchemy_getTokenBalances", family: "evm", gateway: "network" },
+  { name: "getTokenMetadata", rpcMethod: "alchemy_getTokenMetadata", family: "evm", gateway: "network" },
+  { name: "getTokenAllowance", rpcMethod: "alchemy_getTokenAllowance", family: "evm", gateway: "network" },
+  { name: "getAssetTransfers", rpcMethod: "alchemy_getAssetTransfers", family: "evm", gateway: "network" },
+  { name: "getTransactionReceipts", rpcMethod: "alchemy_getTransactionReceipts", family: "evm", gateway: "network" },
+  { name: "simulateAssetChanges", rpcMethod: "alchemy_simulateAssetChanges", family: "evm", gateway: "network" },
+  { name: "simulateExecution", rpcMethod: "alchemy_simulateExecution", family: "evm", gateway: "network" },
+  { name: "traceCall", rpcMethod: "trace_call", family: "evm", gateway: "network" },
+  { name: "traceTransaction", rpcMethod: "trace_transaction", family: "evm", gateway: "network" },
+  { name: "traceBlock", rpcMethod: "trace_block", family: "evm", gateway: "network" },
+  { name: "debugTraceTransaction", rpcMethod: "debug_traceTransaction", family: "evm", gateway: "network" },
+  { name: "debugTraceCall", rpcMethod: "debug_traceCall", family: "evm", gateway: "network" },
+  { name: "estimateUserOperationGas", rpcMethod: "estimateUserOperationGas", family: "evm", gateway: "network" },
+  { name: "getUserOperationReceipt", rpcMethod: "getUserOperationReceipt", family: "evm", gateway: "network" },
+  { name: "getUserOperationByHash", rpcMethod: "getUserOperationByHash", family: "evm", gateway: "network" },
+  { name: "supportedEntryPoints", rpcMethod: "supportedEntryPoints", family: "evm", gateway: "network" },
+  { name: "solana_getAsset", rpcMethod: "getAsset", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByOwner", rpcMethod: "getAssetsByOwner", family: "solana", gateway: "network" },
+  { name: "solana_searchAssets", rpcMethod: "searchAssets", family: "solana", gateway: "network" },
+  { name: "getTokenAccounts", rpcMethod: "getTokenAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getAssets", rpcMethod: "getAssets", family: "solana", gateway: "network" },
+  { name: "solana_getAssetProof", rpcMethod: "getAssetProof", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByAuthority", rpcMethod: "getAssetsByAuthority", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByGroup", rpcMethod: "getAssetsByGroup", family: "solana", gateway: "network" },
+  { name: "solana_getAssetsByCreator", rpcMethod: "getAssetsByCreator", family: "solana", gateway: "network" },
+  { name: "solana_getAssetSignatures", rpcMethod: "getAssetSignatures", family: "solana", gateway: "network" },
+  { name: "getNftEditions", rpcMethod: "getNftEditions", family: "solana", gateway: "network" },
+  { name: "simulateAssetChangesBundle", rpcMethod: "alchemy_simulateAssetChangesBundle", family: "evm", gateway: "network" },
+  { name: "simulateExecutionBundle", rpcMethod: "alchemy_simulateExecutionBundle", family: "evm", gateway: "network" },
+  { name: "simulateUserOperationAssetChanges", rpcMethod: "alchemy_simulateUserOperationAssetChanges", family: "evm", gateway: "network" },
+  { name: "traceFilter", rpcMethod: "trace_filter", family: "evm", gateway: "network" },
+  { name: "traceReplayTransaction", rpcMethod: "trace_replayTransaction", family: "evm", gateway: "network" },
+  { name: "traceReplayBlockTransactions", rpcMethod: "trace_replayBlockTransactions", family: "evm", gateway: "network" },
+  { name: "debugTraceBlockByNumber", rpcMethod: "debug_traceBlockByNumber", family: "evm", gateway: "network" },
+  { name: "debugTraceBlockByHash", rpcMethod: "debug_traceBlockByHash", family: "evm", gateway: "network" },
+  { name: "debugGetRawBlock", rpcMethod: "debug_getRawBlock", family: "evm", gateway: "network" },
+  { name: "debugGetRawReceipts", rpcMethod: "debug_getRawReceipts", family: "evm", gateway: "network" },
+  { name: "requestGasAndPaymasterAndData", rpcMethod: "alchemy_requestGasAndPaymasterAndData", family: "evm", gateway: "network" },
+  { name: "requestPaymasterAndData", rpcMethod: "alchemy_requestPaymasterAndData", family: "evm", gateway: "network" },
+  { name: "ethCall", rpcMethod: "eth_call", family: "evm", gateway: "network" },
+  { name: "ethGetBlockReceipts", rpcMethod: "eth_getBlockReceipts", family: "evm", gateway: "network" },
+  { name: "ethGetProof", rpcMethod: "eth_getProof", family: "evm", gateway: "network" },
+  { name: "ethCreateAccessList", rpcMethod: "eth_createAccessList", family: "evm", gateway: "network" },
+  { name: "ethBlobBaseFee", rpcMethod: "eth_blobBaseFee", family: "evm", gateway: "network" },
+  { name: "rundlerMaxPriorityFeePerGas", rpcMethod: "rundler_maxPriorityFeePerGas", family: "evm", gateway: "network" },
+  { name: "solana_getBalance", rpcMethod: "getBalance", family: "solana", gateway: "network" },
+  { name: "solana_getAccountInfo", rpcMethod: "getAccountInfo", family: "solana", gateway: "network" },
+  { name: "solana_getMultipleAccounts", rpcMethod: "getMultipleAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getTransaction", rpcMethod: "getTransaction", family: "solana", gateway: "network" },
+  { name: "solana_getSignaturesForAddress", rpcMethod: "getSignaturesForAddress", family: "solana", gateway: "network" },
+  { name: "solana_getSignatureStatuses", rpcMethod: "getSignatureStatuses", family: "solana", gateway: "network" },
+  { name: "solana_simulateTransaction", rpcMethod: "simulateTransaction", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountBalance", rpcMethod: "getTokenAccountBalance", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountsByOwner", rpcMethod: "getTokenAccountsByOwner", family: "solana", gateway: "network" },
+  { name: "solana_getTokenAccountsByDelegate", rpcMethod: "getTokenAccountsByDelegate", family: "solana", gateway: "network" },
+  { name: "solana_getTokenSupply", rpcMethod: "getTokenSupply", family: "solana", gateway: "network" },
+  { name: "solana_getTokenLargestAccounts", rpcMethod: "getTokenLargestAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getBlock", rpcMethod: "getBlock", family: "solana", gateway: "network" },
+  { name: "solana_getBlockHeight", rpcMethod: "getBlockHeight", family: "solana", gateway: "network" },
+  { name: "solana_getBlockTime", rpcMethod: "getBlockTime", family: "solana", gateway: "network" },
+  { name: "solana_getBlocks", rpcMethod: "getBlocks", family: "solana", gateway: "network" },
+  { name: "solana_getSlot", rpcMethod: "getSlot", family: "solana", gateway: "network" },
+  { name: "solana_getLatestBlockhash", rpcMethod: "getLatestBlockhash", family: "solana", gateway: "network" },
+  { name: "solana_isBlockhashValid", rpcMethod: "isBlockhashValid", family: "solana", gateway: "network" },
+  { name: "solana_getProgramAccounts", rpcMethod: "getProgramAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getEpochInfo", rpcMethod: "getEpochInfo", family: "solana", gateway: "network" },
+  { name: "solana_getSupply", rpcMethod: "getSupply", family: "solana", gateway: "network" },
+  { name: "solana_getVersion", rpcMethod: "getVersion", family: "solana", gateway: "network" },
+  { name: "solana_getTransactionCount", rpcMethod: "getTransactionCount", family: "solana", gateway: "network" },
+  { name: "solana_getInflationRate", rpcMethod: "getInflationRate", family: "solana", gateway: "network" },
+  { name: "solana_getInflationReward", rpcMethod: "getInflationReward", family: "solana", gateway: "network" },
+  { name: "solana_getVoteAccounts", rpcMethod: "getVoteAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getLargestAccounts", rpcMethod: "getLargestAccounts", family: "solana", gateway: "network" },
+  { name: "solana_getFeeForMessage", rpcMethod: "getFeeForMessage", family: "solana", gateway: "network" },
+  { name: "solana_getRecentPrioritizationFees", rpcMethod: "getRecentPrioritizationFees", family: "solana", gateway: "network" },
+  { name: "solana_getMinimumBalanceForRentExemption", rpcMethod: "getMinimumBalanceForRentExemption", family: "solana", gateway: "network" },
+  { name: "solana_getPriorityFeeEstimate", rpcMethod: "getPriorityFeeEstimate", family: "solana", gateway: "network" },
+  { name: "solana_getClusterNodes", rpcMethod: "getClusterNodes", family: "solana", gateway: "network" },
+  { name: "solana_getLeaderSchedule", rpcMethod: "getLeaderSchedule", family: "solana", gateway: "network" },
+  { name: "solana_getMaxRetransmitSlot", rpcMethod: "getMaxRetransmitSlot", family: "solana", gateway: "network" },
+  { name: "solana_getMaxShredInsertSlot", rpcMethod: "getMaxShredInsertSlot", family: "solana", gateway: "network" },
+  { name: "solana_getRecentPerformanceSamples", rpcMethod: "getRecentPerformanceSamples", family: "solana", gateway: "network" },
+  { name: "solana_getFirstAvailableBlock", rpcMethod: "getFirstAvailableBlock", family: "solana", gateway: "network" },
+  { name: "solana_getGenesisHash", rpcMethod: "getGenesisHash", family: "solana", gateway: "network" },
+  { name: "solana_getHighestSnapshotSlot", rpcMethod: "getHighestSnapshotSlot", family: "solana", gateway: "network" },
+  { name: "solana_getIdentity", rpcMethod: "getIdentity", family: "solana", gateway: "network" },
+  { name: "solana_getInflationGovernor", rpcMethod: "getInflationGovernor", family: "solana", gateway: "network" },
+  { name: "solana_minimumLedgerSlot", rpcMethod: "minimumLedgerSlot", family: "solana", gateway: "network" },
+  { name: "solana_requestAirdrop", rpcMethod: "requestAirdrop", family: "solana", gateway: "network" },
+  { name: "solana_getBlockCommitment", rpcMethod: "getBlockCommitment", family: "solana", gateway: "network" },
+  { name: "solana_getBlockProduction", rpcMethod: "getBlockProduction", family: "solana", gateway: "network" },
+  { name: "solana_getSlotLeader", rpcMethod: "getSlotLeader", family: "solana", gateway: "network" },
+  { name: "solana_getSlotLeaders", rpcMethod: "getSlotLeaders", family: "solana", gateway: "network" },
+  { name: "solana_getEpochSchedule", rpcMethod: "getEpochSchedule", family: "solana", gateway: "network" },
+  { name: "solana_getBlocksWithLimit", rpcMethod: "getBlocksWithLimit", family: "solana", gateway: "network" },
+  { name: "solana_getStakeActivation", rpcMethod: "getStakeActivation", family: "solana", gateway: "network" },
+  { name: "solana_simulateBundle", rpcMethod: "simulateBundle", family: "solana", gateway: "network" }
+];
+var DATA_API_SURFACE = [
+  { name: "getNFTsForOwner", service: "nft", sdkMethod: "getNFTsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTsForContract", service: "nft", sdkMethod: "getNFTsForContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTMetadata", service: "nft", sdkMethod: "getNFTMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTMetadataBatch", service: "nft", sdkMethod: "getNFTMetadataBatch", transport: "post", input: "body", requiresNetwork: true },
+  { name: "getContractMetadata", service: "nft", sdkMethod: "getContractMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getOwnersForNFT", service: "nft", sdkMethod: "getOwnersForNFT", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getOwnersForContract", service: "nft", sdkMethod: "getOwnersForContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getFloorPrice", service: "nft", sdkMethod: "getFloorPrice", transport: "get", input: "query", requiresNetwork: true },
+  { name: "isSpamContract", service: "nft", sdkMethod: "isSpamContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "searchContractMetadata", service: "nft", sdkMethod: "searchContractMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTSales", service: "nft", sdkMethod: "getNFTSales", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getContractsForOwner", service: "nft", sdkMethod: "getContractsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getNFTsForCollection", service: "nft", sdkMethod: "getNFTsForCollection", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getCollectionMetadata", service: "nft", sdkMethod: "getCollectionMetadata", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getContractMetadataBatch", service: "nft", sdkMethod: "getContractMetadataBatch", transport: "post", input: "body", requiresNetwork: true },
+  { name: "getSpamContracts", service: "nft", sdkMethod: "getSpamContracts", transport: "get", input: "none", requiresNetwork: true },
+  { name: "isAirdropNFT", service: "nft", sdkMethod: "isAirdropNFT", transport: "get", input: "query", requiresNetwork: true },
+  { name: "summarizeNFTAttributes", service: "nft", sdkMethod: "summarizeNFTAttributes", transport: "get", input: "query", requiresNetwork: true },
+  { name: "isHolderOfContract", service: "nft", sdkMethod: "isHolderOfContract", transport: "get", input: "query", requiresNetwork: true },
+  { name: "computeRarity", service: "nft", sdkMethod: "computeRarity", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getCollectionsForOwner", service: "nft", sdkMethod: "getCollectionsForOwner", transport: "get", input: "query", requiresNetwork: true },
+  { name: "getTokenPricesBySymbol", service: "prices", sdkMethod: "getTokenPricesBySymbol", transport: "get", input: "query", requiresNetwork: false },
+  { name: "getTokenPricesByAddress", service: "prices", sdkMethod: "getTokenPricesByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getHistoricalTokenPrices", service: "prices", sdkMethod: "getHistoricalTokenPrices", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getTokensByAddress", service: "portfolio", sdkMethod: "getTokensByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getTokenBalancesByAddress", service: "portfolio", sdkMethod: "getTokenBalancesByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getNFTsByAddress", service: "portfolio", sdkMethod: "getNFTsByAddress", transport: "post", input: "body", requiresNetwork: false },
+  { name: "getNFTContractsByAddress", service: "portfolio", sdkMethod: "getNFTContractsByAddress", transport: "post", input: "body", requiresNetwork: false }
+];
+var RPC_API_TOOL_NAMES = RPC_API_SURFACE.map((method) => method.name);
+var DATA_API_TOOL_NAMES = DATA_API_SURFACE.map((method) => method.name);
+
+// src/commands/surface-parity.ts
+function registerEvmRpcSurfaceCommands(root, rpc) {
+  for (const method of RPC_API_SURFACE.filter((entry) => entry.family === "evm")) {
+    registerRpcSurfaceCommand({ root, parent: rpc, method });
+  }
+}
+function registerSolanaRpcSurfaceCommands(root, solana) {
+  for (const method of RPC_API_SURFACE.filter((entry) => entry.family === "solana")) {
+    registerRpcSurfaceCommand({ root, parent: solana, method });
+  }
+}
+function registerDataSurfaceCommands(root, data) {
+  for (const method of DATA_API_SURFACE) {
+    const command = data.command(method.name).description(`Call ${method.name}`);
+    if (method.input === "query") {
+      command.option("--query <json>", "Query parameters as a JSON object", "{}");
+    } else if (method.input === "body") {
+      command.option("--body <json>", "Request body as a JSON object", "{}");
+    }
+    command.action(async (opts) => {
+      try {
+        const apiKey = resolveAPIKey(root);
+        if (!apiKey) {
+          throw errAuthRequired();
+        }
+        const client = createAlchemyDataClient(apiKey, { breadcrumb: "alchemy-cli" });
+        const result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => callDataMethod(client, method, root, opts)
+        );
+        printSyntaxJSON(result);
+      } catch (err) {
+        exitWithError(mapDataError(err));
+      }
+    });
+  }
+}
+function registerRpcSurfaceCommand({ root, parent, method }) {
+  parent.command(method.name).description(`Call ${method.rpcMethod}`).option("--params <json>", "JSON-RPC params as an array or object", "[]").action(async (opts) => {
+    try {
+      const params = parseRpcParams(opts.params);
+      let result;
+      if (method.gateway === "global") {
+        const apiKey = resolveAPIKey(root);
+        if (!apiKey) {
+          throw errAuthRequired();
+        }
+        if (!Array.isArray(params)) {
+          throw errInvalidArgs("--params must be a JSON array for global RPC methods.");
+        }
+        result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => globalRpcCall(apiKey, method.rpcMethod, params, {
+            breadcrumb: "alchemy-cli",
+            ...timeout && { timeoutMs: timeout }
+          })
+        );
+      } else {
+        const client = method.family === "solana" ? clientFromFlags(root, { forceNetwork: resolveSolanaNetwork(root) }) : clientFromFlags(root);
+        result = await withSpinner(
+          `Calling ${method.name}...`,
+          `Called ${method.name}`,
+          () => client.call(method.rpcMethod, params)
+        );
+      }
+      printSyntaxJSON(result);
+    } catch (err) {
+      exitWithError(mapRpcError(err));
+    }
+  });
+}
+function parseRpcParams(input) {
+  const parsed = parseRequiredJSON(input, "--params");
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  throw errInvalidArgs("--params must be a JSON array or object.");
+}
+async function callDataMethod(client, method, root, opts) {
+  if (method.service === "nft") {
+    const fn2 = client.nft[method.sdkMethod];
+    const network = resolveNetwork(root);
+    if (method.input === "none") {
+      return await fn2.call(client.nft, network);
+    }
+    if (method.input === "body") {
+      return await fn2.call(client.nft, network, parseDataObject(opts.body ?? "{}", "--body"));
+    }
+    return await fn2.call(client.nft, network, normalizeQuery(parseDataObject(opts.query ?? "{}", "--query")));
+  }
+  if (method.service === "prices") {
+    const fn2 = client.prices[method.sdkMethod];
+    if (method.input === "body") {
+      return await fn2.call(client.prices, parseDataObject(opts.body ?? "{}", "--body"));
+    }
+    return await fn2.call(client.prices, parseDataObject(opts.query ?? "{}", "--query"));
+  }
+  const fn = client.portfolio[method.sdkMethod];
+  return await fn.call(client.portfolio, parseDataObject(opts.body ?? "{}", "--body"));
+}
+function parseDataObject(input, label) {
+  const parsed = parseRequiredJSON(input, label);
+  if (isPlainObject(parsed)) {
+    return parsed;
+  }
+  throw errInvalidArgs(`${label} must be a JSON object.`);
+}
+function normalizeQuery(input) {
+  const out = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      out[key] = value.map((item) => String(item));
+    } else {
+      out[key] = String(value);
+    }
+  }
+  return out;
+}
+function isPlainObject(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function mapRpcError(err) {
+  if (!(err instanceof RpcApiError)) {
+    return err;
+  }
+  if (err.status === 429) {
+    return errRateLimited();
+  }
+  if (err.status === 401 || err.status === 403) {
+    return errInvalidAPIKey(err.message);
+  }
+  if (err.status !== void 0) {
+    return errNetwork(`HTTP ${err.status}: ${err.message}`);
+  }
+  return errRPC(err.code, err.message);
+}
+function mapDataError(err) {
+  if (!(err instanceof DataApiError)) {
+    return err;
+  }
+  if (err.status === 429) {
+    return errRateLimited();
+  }
+  if (err.status === 401 || err.status === 403) {
+    return errInvalidAPIKey(err.message);
+  }
+  return errNetwork(`HTTP ${err.status}: ${err.message}`);
+}
+
 // src/commands/solana.ts
 function registerReservedSolanaCommand(args) {
   args.cmd.command(args.signature).description(args.description).action(() => {
@@ -5159,6 +5637,7 @@ function registerSolana(program2) {
   registerSolanaProgram(cmd);
   registerSolanaDelegate(cmd);
   registerStatus(cmd, { networkMode: "solana" });
+  registerSolanaRpcSurfaceCommands(program2, cmd);
   registerReservedSolanaCommands(cmd);
 }
 
@@ -5593,7 +6072,108 @@ import {
   erc20Abi,
   maxUint256
 } from "viem";
+
+// src/lib/token-registry.ts
 var NATIVE_TOKEN_ADDRESS = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
+var REGISTRY = {
+  "eth-mainnet": [
+    { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Ether", isNative: true },
+    { symbol: "WETH", address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", decimals: 18, name: "Wrapped Ether" },
+    { symbol: "USDC", address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", decimals: 6, name: "USD Coin" },
+    { symbol: "USDT", address: "0xdAC17F958D2ee523a2206206994597C13D831ec7", decimals: 6, name: "Tether USD" },
+    { symbol: "DAI", address: "0x6B175474E89094C44Da98b954EedeAC495271d0F", decimals: 18, name: "Dai Stablecoin" },
+    { symbol: "WBTC", address: "0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599", decimals: 8, name: "Wrapped BTC" }
+  ],
+  "base-mainnet": [
+    { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Ether", isNative: true },
+    { symbol: "WETH", address: "0x4200000000000000000000000000000000000006", decimals: 18, name: "Wrapped Ether" },
+    { symbol: "USDC", address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", decimals: 6, name: "USD Coin" },
+    { symbol: "USDbC", address: "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA", decimals: 6, name: "USD Base Coin (bridged)" },
+    { symbol: "DAI", address: "0x50c5725949A6F0c72E6C4a641F24049A917DB0Cb", decimals: 18, name: "Dai Stablecoin" },
+    { symbol: "cbETH", address: "0x2Ae3F1Ec7F1F5012CFEab0185bfc7aa3cf0DEc22", decimals: 18, name: "Coinbase Wrapped Staked ETH" }
+  ],
+  "arb-mainnet": [
+    { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Ether", isNative: true },
+    { symbol: "WETH", address: "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1", decimals: 18, name: "Wrapped Ether" },
+    { symbol: "USDC", address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831", decimals: 6, name: "USD Coin" },
+    { symbol: "USDC.e", address: "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8", decimals: 6, name: "Bridged USD Coin (legacy)", aliases: ["USDCe"] },
+    { symbol: "USDT", address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9", decimals: 6, name: "Tether USD" },
+    { symbol: "DAI", address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1", decimals: 18, name: "Dai Stablecoin" },
+    { symbol: "WBTC", address: "0x2f2a2543B76A4166549F7aaB2e75Bef0aefC5B0f", decimals: 8, name: "Wrapped BTC" },
+    { symbol: "ARB", address: "0x912CE59144191C1204E64559FE8253a0e49E6548", decimals: 18, name: "Arbitrum" }
+  ],
+  "opt-mainnet": [
+    { symbol: "ETH", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Ether", isNative: true },
+    { symbol: "WETH", address: "0x4200000000000000000000000000000000000006", decimals: 18, name: "Wrapped Ether" },
+    { symbol: "USDC", address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85", decimals: 6, name: "USD Coin" },
+    { symbol: "USDC.e", address: "0x7F5c764cBc14f9669B88837ca1490cCa17c31607", decimals: 6, name: "Bridged USD Coin (legacy)", aliases: ["USDCe"] },
+    { symbol: "USDT", address: "0x94b008aA00579c1307B0EF2c499aD98a8ce58e58", decimals: 6, name: "Tether USD" },
+    { symbol: "DAI", address: "0xDA10009cBd5D07dd0CeCc66161FC93D7c9000da1", decimals: 18, name: "Dai Stablecoin" },
+    { symbol: "WBTC", address: "0x68f180fcCe6836688e9084f035309E29Bf0A2095", decimals: 8, name: "Wrapped BTC" },
+    { symbol: "OP", address: "0x4200000000000000000000000000000000000042", decimals: 18, name: "Optimism" }
+  ],
+  "polygon-mainnet": [
+    { symbol: "POL", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Polygon Ecosystem Token", isNative: true, aliases: ["MATIC"] },
+    { symbol: "WPOL", address: "0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270", decimals: 18, name: "Wrapped POL", aliases: ["WMATIC"] },
+    { symbol: "USDC", address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359", decimals: 6, name: "USD Coin" },
+    { symbol: "USDC.e", address: "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174", decimals: 6, name: "Bridged USD Coin (legacy)", aliases: ["USDCe"] },
+    { symbol: "USDT", address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F", decimals: 6, name: "Tether USD" },
+    { symbol: "DAI", address: "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063", decimals: 18, name: "Dai Stablecoin" },
+    { symbol: "WETH", address: "0x7ceB23fD6bC0adD59E62ac25578270cFf1b9f619", decimals: 18, name: "Wrapped Ether" },
+    { symbol: "WBTC", address: "0x1BFD67037B42Cf73acF2047067bd4F2C47D9BfD6", decimals: 8, name: "Wrapped BTC" }
+  ],
+  "bnb-mainnet": [
+    { symbol: "BNB", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "BNB", isNative: true },
+    { symbol: "WBNB", address: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c", decimals: 18, name: "Wrapped BNB" },
+    { symbol: "USDC", address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d", decimals: 18, name: "Binance-Peg USD Coin" },
+    { symbol: "USDT", address: "0x55d398326f99059fF775485246999027B3197955", decimals: 18, name: "Binance-Peg Tether USD" },
+    { symbol: "DAI", address: "0x1AF3F329e8BE154074D8769D1FFa4eE058B1DBc3", decimals: 18, name: "Binance-Peg Dai Token" },
+    { symbol: "WETH", address: "0x2170Ed0880ac9A755fd29B2688956BD959F933F8", decimals: 18, name: "Binance-Peg Ether" },
+    { symbol: "BTCB", address: "0x7130d2A12B9BCbFAe4f2634d864A1Ee1Ce3Ead9c", decimals: 18, name: "Binance-Peg BTC" }
+  ],
+  "avax-mainnet": [
+    { symbol: "AVAX", address: NATIVE_TOKEN_ADDRESS, decimals: 18, name: "Avalanche", isNative: true },
+    { symbol: "WAVAX", address: "0xB31f66AA3C1e785363F0875A1B74E27b85FD66c7", decimals: 18, name: "Wrapped AVAX" },
+    { symbol: "USDC", address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E", decimals: 6, name: "USD Coin" },
+    { symbol: "USDC.e", address: "0xA7D7079b0FEaD91F3e65f86E8915Cb59c1a4C664", decimals: 6, name: "Bridged USD Coin (legacy)", aliases: ["USDCe"] },
+    { symbol: "USDT", address: "0x9702230A8Ea53601f5cD2dc00fDBc13d4dF4A8c7", decimals: 6, name: "Tether USD" },
+    { symbol: "USDT.e", address: "0xc7198437980c041c805A1EDcbA50c1Ce5db95118", decimals: 6, name: "Bridged Tether USD (legacy)", aliases: ["USDTe"] },
+    { symbol: "DAI.e", address: "0xd586E7F844cEa2F87f50152665BCbc2C279D8d70", decimals: 18, name: "Bridged Dai Stablecoin" },
+    { symbol: "WETH.e", address: "0x49D5c2BdFfac6CE2BFdB6640F4F80f226bc10bAB", decimals: 18, name: "Bridged Wrapped Ether" }
+  ]
+};
+function normalize(symbol) {
+  return symbol.trim().toUpperCase();
+}
+var INDEX_CACHE = /* @__PURE__ */ new Map();
+function indexFor(network) {
+  const cached = INDEX_CACHE.get(network);
+  if (cached) return cached;
+  const entries = REGISTRY[network] ?? [];
+  const index = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    index.set(normalize(entry.symbol), entry);
+    for (const alias of entry.aliases ?? []) {
+      index.set(normalize(alias), entry);
+    }
+  }
+  INDEX_CACHE.set(network, index);
+  return index;
+}
+function getRegistryNetworks() {
+  return Object.keys(REGISTRY).sort();
+}
+function listRegistryTokens(network) {
+  return REGISTRY[network] ?? [];
+}
+function findRegistryToken(network, symbol) {
+  return indexFor(network).get(normalize(symbol)) ?? null;
+}
+function registrySymbolSuggestions(network) {
+  return listRegistryTokens(network).map((t) => t.symbol);
+}
+
+// src/commands/approve.ts
 function isNativeToken(address2) {
   return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
@@ -7009,6 +7589,7 @@ function registerData(program2) {
   registerTransfers(cmd);
   registerPrices(cmd);
   registerPortfolio(cmd);
+  registerDataSurfaceCommands(program2, cmd);
 }
 
 // src/commands/debug.ts
@@ -7308,7 +7889,7 @@ Tip: use 'alchemy evm tx <hash>' for transaction details (value, block, nonce).
 
 // src/commands/rpc.ts
 function registerRPC(program2) {
-  program2.command("rpc").argument("<method>", "JSON-RPC method name (e.g. eth_blockNumber)").argument("[params...]", "Method parameters as JSON values").description("Make a raw JSON-RPC call").addHelpText(
+  const cmd = program2.command("rpc").argument("<method>", "JSON-RPC method name (e.g. eth_blockNumber)").argument("[params...]", "Method parameters as JSON values").description("Make a raw JSON-RPC call").addHelpText(
     "after",
     `
 Examples:
@@ -7317,6 +7898,9 @@ Examples:
   alchemy evm rpc eth_getBlockByNumber "0x1" true`
   ).action(async (method, params) => {
     try {
+      if (outputRpcHelp(cmd, method, params)) {
+        return;
+      }
       const client = clientFromFlags(program2);
       const parsed = params.map((p) => {
         try {
@@ -7336,6 +7920,24 @@ Examples:
       exitWithError(err);
     }
   });
+  registerEvmRpcSurfaceCommands(program2, cmd);
+}
+function outputRpcHelp(cmd, method, params) {
+  if (method !== "help") {
+    return false;
+  }
+  const [topic] = params;
+  if (!topic) {
+    cmd.outputHelp();
+    return true;
+  }
+  const subcommand = cmd.commands.find((command) => command.name() === topic);
+  if (subcommand) {
+    subcommand.outputHelp();
+    return true;
+  }
+  cmd.outputHelp();
+  return true;
 }
 
 // src/commands/send-evm.ts
@@ -7369,7 +7971,7 @@ Examples:
         dryRun: opts.dryRun
       });
     } catch (err) {
-      const { exitWithError: exitWithError2 } = await import("./errors-T6XE2I2L.js");
+      const { exitWithError: exitWithError2 } = await import("./errors-YPNK3AVF.js");
       exitWithError2(err);
     }
   });
@@ -7638,10 +8240,9 @@ function normalizeQuoteError(err, flow) {
 }
 
 // src/commands/swap.ts
-var NATIVE_TOKEN_ADDRESS2 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 var NATIVE_DECIMALS = 18;
 function isNativeToken2(address2) {
-  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS2.toLowerCase();
+  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
 function slippagePercentToBasisPoints(percent) {
   return BigInt(Math.round(percent * 100));
@@ -7717,6 +8318,11 @@ function registerSwap(program2) {
   quoteCmd.addHelpText(
     "after",
     `
+Tip: use 'alchemy evm token <SYMBOL>' to resolve common token addresses
+(ETH, USDC, WETH, USDT, DAI, \u2026). Example:
+  --from $(alchemy evm token ETH --address-only) \\
+  --to $(alchemy evm token USDC --address-only -n eth-mainnet)
+
 Examples:
   alchemy evm swap quote --from 0xEeee...EEeE --to 0xA0b8...USDC --amount 1.0 -n eth-mainnet
   alchemy evm swap quote --from 0xUSDC --to 0xDAI --amount 100 --slippage 1.0`
@@ -7732,6 +8338,10 @@ Examples:
   executeCmd.option("--gas-sponsored", "Enable gas sponsorship (env: ALCHEMY_EVM_GAS_SPONSORED)").option("--gas-policy-id <id>", "Gas policy ID for sponsorship (env: ALCHEMY_EVM_GAS_POLICY_ID)").addHelpText(
     "after",
     `
+Tip: use 'alchemy evm token <SYMBOL>' to resolve common token addresses
+(ETH, USDC, WETH, USDT, DAI, \u2026). Run 'alchemy evm token list' to discover
+known symbols on the current network.
+
 Examples:
   alchemy evm swap execute --from 0xEeee...EEeE --to 0xA0b8...USDC --amount 1.0 -n eth-mainnet
   alchemy evm swap execute --from 0xUSDC --to 0xDAI --amount 100 --slippage 1.0
@@ -7894,6 +8504,153 @@ function extractQuoteData(quote) {
   return { type };
 }
 
+// src/commands/evm-token.ts
+function tokenJSON(token, network) {
+  return {
+    symbol: token.symbol,
+    address: token.address,
+    decimals: token.decimals,
+    name: token.name,
+    network,
+    isNative: token.isNative === true,
+    ...token.aliases?.length ? { aliases: token.aliases } : {}
+  };
+}
+function registerEvmToken(program2) {
+  const cmd = program2.command("token").description(
+    "Look up known token addresses by symbol (ETH, USDC, WETH, etc.)"
+  ).argument("[symbol]", "Token symbol (e.g. ETH, USDC, WETH)").option("--address-only", "Print only the resolved address (for scripting)").addHelpText(
+    "after",
+    `
+Symbols are matched case-insensitively. \`USDC\` resolves to the canonical
+Circle-issued token; \`USDC.e\` resolves to the legacy bridged variant where
+applicable. The native gas token (ETH, POL, BNB, AVAX, \u2026) resolves to the
+EIP-7528 native sentinel 0xEeee\u2026EEeE.
+
+Examples:
+  alchemy evm token ETH                          # uses current network
+  alchemy evm token USDC -n base-mainnet
+  alchemy evm token USDC.e -n arb-mainnet
+  alchemy evm token USDC --address-only           # prints just the 0x address
+  alchemy --json evm token USDC | jq -r .address
+
+  alchemy evm token list                          # list tokens on current network
+  alchemy evm token list --all                    # list tokens across all networks`
+  ).action(async (symbol, opts) => {
+    try {
+      if (!symbol) {
+        if (opts.addressOnly) {
+          throw errInvalidArgs(
+            "--address-only requires a symbol. Example: alchemy evm token USDC --address-only"
+          );
+        }
+        await runList(program2, {});
+        return;
+      }
+      await runLookup(program2, symbol, opts);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+  cmd.command("list").description("List known token symbols and addresses").option("--all", "List tokens across all supported networks").action(async (opts) => {
+    try {
+      await runList(program2, opts);
+    } catch (err) {
+      exitWithError(err);
+    }
+  });
+}
+async function runLookup(program2, symbol, opts) {
+  const network = resolveNetwork(program2);
+  const token = findRegistryToken(network, symbol);
+  if (!token) {
+    const supported = registrySymbolSuggestions(network);
+    if (supported.length === 0) {
+      throw errInvalidArgs(
+        `No token registry entries for network ${network}. Run 'alchemy evm token list --all' to see supported networks, or pass the raw 0x address.`
+      );
+    }
+    throw errNotFound(
+      `token symbol "${symbol}" on ${network}. Known symbols: ${supported.join(", ")}.`
+    );
+  }
+  if (opts.addressOnly) {
+    console.log(token.address);
+    return;
+  }
+  if (isJSONMode()) {
+    printJSON(tokenJSON(token, network));
+    return;
+  }
+  const pairs = [
+    ["Symbol", green(token.symbol)],
+    ["Name", token.name],
+    ["Address", token.address],
+    ["Decimals", String(token.decimals)],
+    ["Network", network]
+  ];
+  if (token.isNative) pairs.push(["Native", "yes"]);
+  if (token.aliases?.length) pairs.push(["Aliases", token.aliases.join(", ")]);
+  printKeyValue(pairs);
+}
+async function runList(program2, opts) {
+  if (opts.all) {
+    const data = getRegistryNetworks().map((network2) => ({
+      network: network2,
+      tokens: listRegistryTokens(network2)
+    }));
+    if (isJSONMode()) {
+      printJSON(
+        data.map(({ network: network2, tokens: tokens2 }) => ({
+          network: network2,
+          tokens: tokens2.map((t) => tokenJSON(t, network2))
+        }))
+      );
+      return;
+    }
+    for (let i = 0; i < data.length; i++) {
+      const { network: network2, tokens: tokens2 } = data[i];
+      if (i > 0) console.log("");
+      console.log(`  ${green(network2)}  ${dim(`(${tokens2.length} tokens)`)}`);
+      printTokenTable(tokens2);
+    }
+    console.log(
+      `
+  ${dim("Tip: pass -n/--network <net> to scope a lookup. Use 'alchemy evm token <SYMBOL>' to fetch a single address.")}`
+    );
+    return;
+  }
+  const network = resolveNetwork(program2);
+  const tokens = listRegistryTokens(network);
+  if (isJSONMode()) {
+    printJSON({ network, tokens: tokens.map((t) => tokenJSON(t, network)) });
+    return;
+  }
+  if (tokens.length === 0) {
+    console.log(
+      `
+  ${dim(`No registry entries for ${network}. Supported networks: ${getRegistryNetworks().join(", ")}.`)}`
+    );
+    return;
+  }
+  console.log(`  ${green(network)}  ${dim(`(${tokens.length} tokens)`)}`);
+  printTokenTable(tokens);
+  console.log(
+    `
+  ${dim("Tip: 'alchemy evm token <SYMBOL>' resolves one symbol. Add --all to see every network.")}`
+  );
+}
+function printTokenTable(tokens) {
+  const rows = tokens.map((t) => [
+    t.symbol,
+    t.name,
+    t.address,
+    String(t.decimals),
+    t.isNative ? "yes" : ""
+  ]);
+  printTable(["Symbol", "Name", "Address", "Decimals", "Native"], rows);
+}
+
 // src/commands/trace.ts
 function normalizeTraceMethod(method) {
   if (method.startsWith("trace_")) return method;
@@ -7990,6 +8747,7 @@ function registerEvm(program2) {
   registerEvmSend(cmd);
   registerContract(cmd);
   registerSwap(cmd);
+  registerEvmToken(cmd);
   registerApprove(cmd);
   registerStatus(cmd);
   registerNetwork(cmd);
@@ -8175,10 +8933,9 @@ function registerGasManager(program2) {
 import {
   swapActions as swapActions2
 } from "@alchemy/wallet-apis/experimental";
-var NATIVE_TOKEN_ADDRESS3 = "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE";
 var NATIVE_DECIMALS2 = 18;
 function isNativeToken3(address2) {
-  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS3.toLowerCase();
+  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
 function slippagePercentToBasisPoints2(percent) {
   return BigInt(Math.round(percent * 100));
@@ -8269,7 +9026,7 @@ function extractQuoteData2(quote) {
 }
 function registerBridge(program2) {
   const cmd = program2.command("bridge").description("Bridge tokens from the source -n/--network to a destination --to-network");
-  const quoteCmd = cmd.command("quote").description("Get a bridge quote without executing").requiredOption("--from <token_address>", `Source token address (use ${NATIVE_TOKEN_ADDRESS3} for the native token)`).requiredOption("--to <token_address>", `Destination token address (use ${NATIVE_TOKEN_ADDRESS3} for the native token)`).requiredOption("--amount <number>", "Amount to bridge in decimal token units (for example, 1.5)").requiredOption("--to-network <network>", "Destination network (e.g. base-mainnet)").option("--from-address <address>", "Wallet/account address to quote from without changing signer selection").option("--slippage <percent>", "Max slippage percentage (omit to use the API default)");
+  const quoteCmd = cmd.command("quote").description("Get a bridge quote without executing").requiredOption("--from <token_address>", `Source token address (use ${NATIVE_TOKEN_ADDRESS} for the native token)`).requiredOption("--to <token_address>", `Destination token address (use ${NATIVE_TOKEN_ADDRESS} for the native token)`).requiredOption("--amount <number>", "Amount to bridge in decimal token units (for example, 1.5)").requiredOption("--to-network <network>", "Destination network (e.g. base-mainnet)").option("--from-address <address>", "Wallet/account address to quote from without changing signer selection").option("--slippage <percent>", "Max slippage percentage (omit to use the API default)");
   addSignerOption(quoteCmd);
   quoteCmd.addHelpText(
     "after",
@@ -8277,8 +9034,11 @@ function registerBridge(program2) {
 Source network comes from the global -n/--network flag. Use --to-network for the destination chain.
 For same-chain token exchanges, use 'alchemy evm swap'.
 
+Tip: use 'alchemy evm token <SYMBOL>' to resolve common token addresses
+(ETH, USDC, WETH, USDT, DAI, \u2026) per chain.
+
 Examples:
-  alchemy xchain bridge quote --from ${NATIVE_TOKEN_ADDRESS3} --to ${NATIVE_TOKEN_ADDRESS3} --amount 0.1 --to-network base-mainnet -n eth-mainnet
+  alchemy xchain bridge quote --from ${NATIVE_TOKEN_ADDRESS} --to ${NATIVE_TOKEN_ADDRESS} --amount 0.1 --to-network base-mainnet -n eth-mainnet
   alchemy xchain bridge quote --from <eth_usdc_address> --to <arb_usdc_address> --amount 100 --to-network arb-mainnet -n eth-mainnet`
   ).action(async (opts) => {
     try {
@@ -8287,7 +9047,7 @@ Examples:
       exitWithError(err);
     }
   });
-  const executeCmd = cmd.command("execute").description("Execute a cross-chain bridge").requiredOption("--from <token_address>", `Source token address (use ${NATIVE_TOKEN_ADDRESS3} for the native token)`).requiredOption("--to <token_address>", `Destination token address (use ${NATIVE_TOKEN_ADDRESS3} for the native token)`).requiredOption("--amount <number>", "Amount to bridge in decimal token units (for example, 1.5)").requiredOption("--to-network <network>", "Destination network (e.g. base-mainnet)").option("--slippage <percent>", "Max slippage percentage (omit to use the API default)");
+  const executeCmd = cmd.command("execute").description("Execute a cross-chain bridge").requiredOption("--from <token_address>", `Source token address (use ${NATIVE_TOKEN_ADDRESS} for the native token)`).requiredOption("--to <token_address>", `Destination token address (use ${NATIVE_TOKEN_ADDRESS} for the native token)`).requiredOption("--amount <number>", "Amount to bridge in decimal token units (for example, 1.5)").requiredOption("--to-network <network>", "Destination network (e.g. base-mainnet)").option("--slippage <percent>", "Max slippage percentage (omit to use the API default)");
   addSignerOption(executeCmd);
   executeCmd.option("--gas-sponsored", "Enable gas sponsorship (env: ALCHEMY_EVM_GAS_SPONSORED)").option("--gas-policy-id <id>", "Gas policy ID for sponsorship (env: ALCHEMY_EVM_GAS_POLICY_ID)").addHelpText(
     "after",
@@ -8295,8 +9055,11 @@ Examples:
 Source network comes from the global -n/--network flag. Use --to-network for the destination chain.
 For same-chain token exchanges, use 'alchemy evm swap'.
 
+Tip: use 'alchemy evm token <SYMBOL>' to resolve common token addresses
+(ETH, USDC, WETH, USDT, DAI, \u2026) per chain.
+
 Examples:
-  alchemy xchain bridge execute --from ${NATIVE_TOKEN_ADDRESS3} --to ${NATIVE_TOKEN_ADDRESS3} --amount 0.1 --to-network base-mainnet -n eth-mainnet
+  alchemy xchain bridge execute --from ${NATIVE_TOKEN_ADDRESS} --to ${NATIVE_TOKEN_ADDRESS} --amount 0.1 --to-network base-mainnet -n eth-mainnet
   alchemy xchain bridge execute --from <eth_usdc_address> --to <arb_usdc_address> --amount 100 --to-network arb-mainnet --gas-sponsored --gas-policy-id <id> -n eth-mainnet`
   ).action(async (_opts, cmd2) => {
     try {
@@ -9125,7 +9888,7 @@ async function flushProcessOutput() {
 }
 program.name("alchemy").description(
   "The Alchemy CLI lets you query blockchain data, call JSON-RPC methods, and manage your Alchemy configuration."
-).version("0.9.1", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
+).version("0.9.3", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
   "-n, --network <network>",
   "Target network (default: eth-mainnet) (env: ALCHEMY_NETWORK)"
 ).option("--x402", "Use x402 wallet-based gateway auth").option(
@@ -9312,11 +10075,11 @@ ${styledLine}`;
     "wallet"
   ];
   if (!skipAppPrompt.includes(cmdName) && isInteractiveAllowed(program) && !opts.apiKey && !process.env.ALCHEMY_API_KEY) {
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-FQ66OWT7.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-REZCFZZ7.js");
     const authToken = resolveAuthToken2(cfg);
     const hasApiKey = Boolean(cfg.api_key?.trim() || cfg.app?.apiKey);
     if (authToken && !hasApiKey) {
-      const { selectAppAfterAuth } = await import("./auth-6BBITIOZ.js");
+      const { selectAppAfterAuth } = await import("./auth-23OYLRWN.js");
       console.log("");
       console.log(`  No app selected. Please select an app to continue.`);
       await selectAppAfterAuth(authToken);
@@ -9351,7 +10114,7 @@ ${styledLine}`;
   if (isInteractiveAllowed(program)) {
     let latestForInteractiveStartup = null;
     if (shouldRunOnboarding(program, cfg)) {
-      const { runOnboarding } = await import("./onboarding-ZLBWCNTB.js");
+      const { runOnboarding } = await import("./onboarding-IJQ72DK7.js");
       const latest = getAvailableUpdateOnce();
       const completed = await runOnboarding(program, latest);
       updateShownDuringInteractiveStartup = Boolean(latest);
@@ -9365,7 +10128,7 @@ ${styledLine}`;
         latestForInteractiveStartup
       );
     }
-    const { startREPL } = await import("./interactive-IFPSMRMX.js");
+    const { startREPL } = await import("./interactive-KLVEYTQM.js");
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {