@alchemy/cli 0.9.2 → 0.10.0

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-HGFU4JCS.js";
+} from "./chunk-HRWD4V2P.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";
@@ -214,11 +222,11 @@ async function resolveENS(name, client) {
   if (dataHex.length < 64) {
     throw errInvalidArgs(`ENS name "${name}" could not be resolved.`);
   }
-  const address2 = "0x" + dataHex.slice(24, 64);
-  if (address2 === "0x0000000000000000000000000000000000000000") {
+  const address3 = "0x" + dataHex.slice(24, 64);
+  if (address3 === "0x0000000000000000000000000000000000000000") {
     throw errInvalidArgs(`ENS name "${name}" is not registered or has no address set.`);
   }
-  return address2;
+  return address3;
 }
 
 // src/lib/validators.ts
@@ -259,10 +267,10 @@ async function readStdinLines(name) {
   }
   return lines;
 }
-function validateAddress(address2) {
-  if (!ADDRESS_RE.test(address2)) {
+function validateAddress(address3) {
+  if (!ADDRESS_RE.test(address3)) {
     throw errInvalidArgs(
-      `Invalid address "${address2}". Expected 0x-prefixed 40-hex-character address.`
+      `Invalid address "${address3}". Expected 0x-prefixed 40-hex-character address.`
     );
   }
 }
@@ -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);
@@ -2026,14 +2034,14 @@ function formatWalletStatus(value) {
 function walletKeysDirPath() {
   return join(configDir(), WALLET_KEYS_DIR);
 }
-function walletKeyPath(prefix, address2) {
-  const addr = address2.trim().toLowerCase().replace(/^0x/, "").replace(/[^a-z0-9]/g, "").slice(0, ADDRESS_SLICE_LEN);
+function walletKeyPath(prefix, address3) {
+  const addr = address3.trim().toLowerCase().replace(/^0x/, "").replace(/[^a-z0-9]/g, "").slice(0, ADDRESS_SLICE_LEN);
   const addressTag = addr || "unknown";
   const fileName = `${prefix}-${addressTag}-${Date.now()}-${randomUUID().slice(0, UUID_SLICE_LEN)}.txt`;
   return join(walletKeysDirPath(), fileName);
 }
-function persistWalletKey(prefix, privateKey, address2) {
-  const keyPath = walletKeyPath(prefix, address2);
+function persistWalletKey(prefix, privateKey, address3) {
+  const keyPath = walletKeyPath(prefix, address3);
   mkdirSync(dirname(keyPath), { recursive: true, mode: 493 });
   writeFileSync(keyPath, privateKey + "\n", { mode: 384, flag: "wx" });
   return keyPath;
@@ -2144,11 +2152,11 @@ function importAndPersistWallet(path) {
   } catch {
     throw errInvalidArgs(`Could not read key file: ${path}`);
   }
-  const address2 = getEvmWalletAddress(key);
-  const keyPath = persistWalletKey("wallet-key", key, address2);
+  const address3 = getEvmWalletAddress(key);
+  const keyPath = persistWalletKey("wallet-key", key, address3);
   const cfg = load();
-  save({ ...cfg, wallet_key_file: keyPath, wallet_address: address2 });
-  return { address: address2, keyFile: keyPath };
+  save({ ...cfg, wallet_key_file: keyPath, wallet_address: address3 });
+  return { address: address3, keyFile: keyPath };
 }
 function hasValidSessionWithEvm() {
   const session = resolveWalletSession();
@@ -2568,43 +2576,42 @@ 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."
-      );
+      mode = "session";
+    } else {
+      const choice = await promptSelect({
+        message: "Choose a wallet to connect",
+        options: [
+          { value: "session", label: "Session wallet", hint: "Recommended \u2014 Alchemy-managed, more secure" },
+          { value: "local", label: "Local wallet", hint: "Private key stored on this machine" }
+        ],
+        initialValue: "session",
+        cancelMessage: "Wallet connect cancelled."
+      });
+      if (choice === null) throw new WalletConnectInterruptedError();
+      mode = choice;
     }
-    const choice = await promptSelect({
-      message: "Choose a wallet to connect",
-      options: [
-        { value: "session", label: "Session wallet", hint: "Recommended \u2014 Alchemy-managed, more secure" },
-        { value: "local", label: "Local wallet", hint: "Private key stored on this machine" }
-      ],
-      initialValue: "session",
-      cancelMessage: "Wallet connect cancelled."
-    });
-    if (choice === null) throw new WalletConnectInterruptedError();
-    mode2 = choice;
   }
-  if (mode2 === "session") {
+  if (mode === "session") {
     await runSessionConnect({
       program: program2,
       force,
@@ -3097,15 +3104,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 +3121,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,
@@ -4119,15 +4126,176 @@ function printAccountSummary(args) {
 
 // src/commands/send-solana.ts
 import { address as solAddress2 } from "@solana/kit";
+
+// src/lib/solana-token.ts
+import {
+  AccountRole as AccountRole2,
+  address as address2,
+  getAddressEncoder,
+  getProgramDerivedAddress
+} from "@solana/kit";
+var SPL_TOKEN_PROGRAM_ADDRESS2 = address2("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
+var SPL_TOKEN_2022_PROGRAM_ADDRESS = address2("TokenzQdBNbLqP5VEhdkAS6EPYdWnYARjfkM8GoyZ2G");
+var ASSOCIATED_TOKEN_PROGRAM_ADDRESS = address2("ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL");
+var SYSTEM_PROGRAM_ADDRESS2 = address2("11111111111111111111111111111111");
+var SUPPORTED_TOKEN_PROGRAMS = /* @__PURE__ */ new Set([
+  SPL_TOKEN_PROGRAM_ADDRESS2,
+  SPL_TOKEN_2022_PROGRAM_ADDRESS
+]);
+async function deriveAssociatedTokenAccount(args) {
+  const addressEncoder = getAddressEncoder();
+  const [associatedTokenAccount] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    seeds: [
+      addressEncoder.encode(args.owner),
+      addressEncoder.encode(args.tokenProgramAddress),
+      addressEncoder.encode(args.mint)
+    ]
+  });
+  return associatedTokenAccount;
+}
+async function fetchSplMintInfo(client, mint) {
+  const account = await fetchParsedAccount(client, mint);
+  if (!account) {
+    throw errInvalidArgs(`SPL token mint ${mint} was not found on this network.`);
+  }
+  const tokenProgramAddress = address2(account.owner);
+  assertSupportedTokenProgram(tokenProgramAddress);
+  const data = parseAccountData(account.data);
+  const decimals = data?.parsed?.info?.decimals;
+  if (typeof decimals !== "number" || !Number.isInteger(decimals) || decimals < 0 || decimals > 255) {
+    throw errInvalidArgs(`Could not read decimals for SPL token mint ${mint}.`);
+  }
+  return {
+    mint,
+    decimals,
+    tokenProgramAddress
+  };
+}
+async function fetchSplTokenAccountInfo(client, tokenAccount) {
+  const account = await fetchParsedAccount(client, tokenAccount);
+  if (!account) return null;
+  const tokenProgramAddress = address2(account.owner);
+  assertSupportedTokenProgram(tokenProgramAddress);
+  const data = parseAccountData(account.data);
+  const info = data?.parsed?.info;
+  if (!info || data?.parsed?.type !== "account") {
+    throw errInvalidArgs(`Account ${tokenAccount} is not an SPL token account.`);
+  }
+  const mint = readAddressField(info, "mint", `Account ${tokenAccount} is missing token mint metadata.`);
+  const owner = readAddressField(info, "owner", `Account ${tokenAccount} is missing token owner metadata.`);
+  return {
+    address: tokenAccount,
+    mint,
+    owner,
+    tokenProgramAddress
+  };
+}
+function buildCreateAssociatedTokenAccountIdempotentInstruction(args) {
+  return {
+    programAddress: ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
+    accounts: [
+      { address: args.payer.address, role: AccountRole2.WRITABLE_SIGNER },
+      { address: args.associatedTokenAccount, role: AccountRole2.WRITABLE },
+      { address: args.owner, role: AccountRole2.READONLY },
+      { address: args.mint, role: AccountRole2.READONLY },
+      { address: SYSTEM_PROGRAM_ADDRESS2, role: AccountRole2.READONLY },
+      { address: args.tokenProgramAddress, role: AccountRole2.READONLY }
+    ],
+    data: new Uint8Array([1])
+  };
+}
+function buildSplTokenTransferCheckedInstruction(args) {
+  if (!Number.isInteger(args.decimals) || args.decimals < 0 || args.decimals > 255) {
+    throw errInvalidArgs("Token decimals must be an integer between 0 and 255.");
+  }
+  return {
+    programAddress: args.tokenProgramAddress,
+    accounts: [
+      { address: args.sourceTokenAccount, role: AccountRole2.WRITABLE },
+      { address: args.mint, role: AccountRole2.READONLY },
+      { address: args.destinationTokenAccount, role: AccountRole2.WRITABLE },
+      { address: args.owner.address, role: AccountRole2.READONLY_SIGNER }
+    ],
+    data: new Uint8Array([
+      12,
+      ...encodeU64LE2(args.amount),
+      args.decimals
+    ])
+  };
+}
+function assertTokenAccountMatches(args) {
+  if (args.account.mint !== args.expectedMint) {
+    throw errInvalidArgs(
+      `${args.label} ${args.account.address} is for mint ${args.account.mint}, expected ${args.expectedMint}.`
+    );
+  }
+  if (args.expectedOwner && args.account.owner !== args.expectedOwner) {
+    throw errInvalidArgs(
+      `${args.label} ${args.account.address} is owned by ${args.account.owner}, expected ${args.expectedOwner}.`
+    );
+  }
+}
+function assertSupportedTokenProgram(tokenProgramAddress) {
+  if (!SUPPORTED_TOKEN_PROGRAMS.has(tokenProgramAddress)) {
+    throw errInvalidArgs(
+      `Unsupported Solana token program ${tokenProgramAddress}. Only SPL Token and Token-2022 mints are supported.`
+    );
+  }
+}
+async function fetchParsedAccount(client, accountAddress) {
+  const result = await client.call("getAccountInfo", [
+    accountAddress,
+    { encoding: "jsonParsed" }
+  ]);
+  return result.value;
+}
+function parseAccountData(data) {
+  if (!data || typeof data !== "object" || Array.isArray(data)) return null;
+  return data;
+}
+function readAddressField(info, field, errorMessage) {
+  const value = info[field];
+  if (typeof value !== "string") {
+    throw errInvalidArgs(errorMessage);
+  }
+  return address2(value);
+}
+function encodeU64LE2(value) {
+  if (value < 0n || value > 0xffffffffffffffffn) {
+    throw errInvalidArgs("Amount must fit in an unsigned 64-bit integer.");
+  }
+  const bytes = new Uint8Array(8);
+  let remaining = value;
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = Number(remaining & 0xffn);
+    remaining >>= 8n;
+  }
+  return bytes;
+}
+
+// src/commands/send-solana.ts
 function registerSolanaSend(program2) {
-  const sendCmd = program2.command("send <to> <amount>").description("Send SOL to an address").option("--token <address>", "SPL token contract address (not yet supported)").option("--fee-sponsored", "Enable Solana fee sponsorship").option("--fee-policy-id <id>", "Solana fee policy ID for sponsorship");
+  const sendCmd = program2.command("send <to> <amount>").description("Send SOL or SPL tokens to an address").option("--token <mint>", "SPL token mint address (omit for native SOL)").option("--dry-run", "Preview transaction without signing or sending").option("--fail-if-associated-token-account-missing", "Fail if the recipient associated token account is missing").option("--from-token-account <address>", "Source SPL token account (defaults to sender associated token account)").option("--recipient-token-account <address>", "Destination SPL token account (defaults to recipient associated token account)").option("--fee-sponsored", "Enable Solana fee sponsorship").option("--fee-policy-id <id>", "Solana fee policy ID for sponsorship").addHelpText(
+    "after",
+    `
+Examples:
+  alchemy solana send <pubkey> 0.1
+  alchemy solana send <pubkey> 10 --token <mint>
+  alchemy solana send <pubkey> 10 --token <mint> --dry-run
+  alchemy solana send <pubkey> 10 --token <mint> --fail-if-associated-token-account-missing`
+  );
   addSignerOption(sendCmd);
   sendCmd.action(
     async (toArg, amountArg, _opts, actionCommand) => {
       try {
         const opts = actionCommand.opts();
         await performSolanaSend(actionCommand, toArg, amountArg, opts.token, {
-          signer: parseSignerOpt(opts.signer)
+          signer: parseSignerOpt(opts.signer),
+          dryRun: opts.dryRun,
+          failIfAssociatedTokenAccountMissing: opts.failIfAssociatedTokenAccountMissing,
+          fromTokenAccount: opts.fromTokenAccount,
+          recipientTokenAccount: opts.recipientTokenAccount
         });
       } catch (err) {
         exitWithError(err);
@@ -4136,75 +4304,378 @@ function registerSolanaSend(program2) {
   );
 }
 async function performSolanaSend(program2, toArg, amountArg, tokenAddress, opts = {}) {
-  if (tokenAddress) {
-    throw errInvalidArgs("SPL token transfers are not yet supported. Omit --token for native SOL transfers.");
-  }
+  validateSolanaTokenOptions(tokenAddress, opts);
   const signer = await resolveSolanaSigner(program2, opts.signer);
   validateSolanaAddress(toArg);
   const to = solAddress2(toArg);
   const network = resolveSolanaNetwork(program2);
-  const symbol = nativeTokenSymbol(network);
-  const lamports = parseAmount(amountArg, SOL_DECIMALS);
-  const instruction = buildSolTransferInstruction(
-    { address: solAddress2(signer.address) },
+  const { sponsored, feePolicyId } = await resolveSolanaFeeSponsorship(program2);
+  const client = clientFromFlags(program2, { forceNetwork: network });
+  if (tokenAddress) {
+    await performSplTokenSend({
+      client,
+      signer,
+      to,
+      toArg,
+      amountArg,
+      tokenAddress,
+      network,
+      sponsored,
+      feePolicyId,
+      opts
+    });
+    return;
+  }
+  await performNativeSolSend({
+    client,
+    signer,
     to,
+    toArg,
+    amountArg,
+    network,
+    sponsored,
+    feePolicyId,
+    dryRun: opts.dryRun
+  });
+}
+async function performNativeSolSend(args) {
+  const symbol = nativeTokenSymbol(args.network);
+  const lamports = parseAmount(args.amountArg, SOL_DECIMALS);
+  const instruction = buildSolTransferInstruction(
+    { address: solAddress2(args.signer.address) },
+    args.to,
     lamports
   );
-  const { sponsored, feePolicyId } = await resolveSolanaFeeSponsorship(program2);
-  const client = clientFromFlags(program2, { forceNetwork: network });
+  if (args.dryRun) {
+    printNativeDryRun({
+      from: args.signer.address,
+      to: args.toArg,
+      amount: args.amountArg,
+      symbol,
+      network: args.network,
+      sponsored: args.sponsored
+    });
+    return;
+  }
   const result = await withSpinner(
     "Sending transaction\u2026",
     "Transaction submitted",
     async () => {
-      if (signer.type === "session") {
+      if (args.signer.type === "session") {
         return await buildAndSendSolanaTransactionWithSession({
-          client,
+          client: args.client,
           instructions: [instruction],
-          session: signer.session,
-          authToken: signer.authToken,
-          sponsored,
-          gasPolicyId: feePolicyId
+          session: args.signer.session,
+          authToken: args.signer.authToken,
+          sponsored: args.sponsored,
+          gasPolicyId: args.feePolicyId
         });
       }
       return await buildAndSendSolanaTransaction({
-        client,
+        client: args.client,
         instructions: [instruction],
-        senderKeyBytes: signer.keyBytes,
-        sponsored,
-        gasPolicyId: feePolicyId
+        senderKeyBytes: args.signer.keyBytes,
+        sponsored: args.sponsored,
+        gasPolicyId: args.feePolicyId
       });
     }
   );
   const confirmed = await withSpinner(
     "Waiting for confirmation\u2026",
     "Confirmation status received",
-    () => waitForSolanaConfirmation(client, result.signature)
+    () => waitForSolanaConfirmation(args.client, result.signature)
+  );
+  printNativeResult({
+    result,
+    to: args.toArg,
+    amount: args.amountArg,
+    symbol,
+    network: args.network,
+    sponsored: args.sponsored,
+    status: confirmed ? "confirmed" : "pending"
+  });
+}
+function validateSolanaTokenOptions(tokenAddress, opts) {
+  if (tokenAddress) return;
+  const splOnlyFlags = [
+    opts.fromTokenAccount ? "--from-token-account" : void 0,
+    opts.recipientTokenAccount ? "--recipient-token-account" : void 0,
+    opts.failIfAssociatedTokenAccountMissing ? "--fail-if-associated-token-account-missing" : void 0
+  ].filter((flag) => flag !== void 0);
+  if (splOnlyFlags.length === 0) return;
+  throw errInvalidArgs(
+    `${splOnlyFlags.join(", ")} ${splOnlyFlags.length === 1 ? "requires" : "require"} --token <mint>.`
+  );
+}
+async function performSplTokenSend(args) {
+  validateSolanaAddress(args.tokenAddress);
+  if (args.opts.fromTokenAccount) validateSolanaAddress(args.opts.fromTokenAccount);
+  if (args.opts.recipientTokenAccount) validateSolanaAddress(args.opts.recipientTokenAccount);
+  const mint = solAddress2(args.tokenAddress);
+  const owner = solAddress2(args.signer.address);
+  const mintInfo = await fetchSplMintInfo(args.client, mint);
+  const amount = parseAmount(args.amountArg, mintInfo.decimals);
+  const plan = await buildSplSendPlan({
+    client: args.client,
+    owner,
+    recipient: args.to,
+    mint,
+    amount,
+    decimals: mintInfo.decimals,
+    tokenProgramAddress: mintInfo.tokenProgramAddress,
+    failIfAssociatedTokenAccountMissing: Boolean(args.opts.failIfAssociatedTokenAccountMissing),
+    fromTokenAccount: args.opts.fromTokenAccount ? solAddress2(args.opts.fromTokenAccount) : void 0,
+    recipientTokenAccount: args.opts.recipientTokenAccount ? solAddress2(args.opts.recipientTokenAccount) : void 0
+  });
+  if (args.opts.dryRun) {
+    printSplDryRun({
+      from: args.signer.address,
+      to: args.toArg,
+      amount: args.amountArg,
+      network: args.network,
+      sponsored: args.sponsored,
+      plan
+    });
+    return;
+  }
+  const result = await submitSolanaInstructions({
+    client: args.client,
+    signer: args.signer,
+    instructions: plan.instructions,
+    sponsored: args.sponsored,
+    feePolicyId: args.feePolicyId
+  });
+  const confirmed = await withSpinner(
+    "Waiting for confirmation\u2026",
+    "Confirmation status received",
+    () => waitForSolanaConfirmation(args.client, result.signature)
+  );
+  printSplResult({
+    result,
+    to: args.toArg,
+    amount: args.amountArg,
+    network: args.network,
+    sponsored: args.sponsored,
+    plan,
+    status: confirmed ? "confirmed" : "pending"
+  });
+}
+async function buildSplSendPlan(args) {
+  const sourceTokenAccount = args.fromTokenAccount ?? await deriveAssociatedTokenAccount({
+    owner: args.owner,
+    mint: args.mint,
+    tokenProgramAddress: args.tokenProgramAddress
+  });
+  const sourceAccount = await fetchSplTokenAccountInfo(args.client, sourceTokenAccount);
+  if (!sourceAccount) {
+    throw errInvalidArgs(
+      `Source token account ${sourceTokenAccount} was not found. Fund the sender's associated token account for mint ${args.mint} and retry.`
+    );
+  }
+  assertTokenAccountMatches({
+    account: sourceAccount,
+    expectedMint: args.mint,
+    expectedOwner: args.owner,
+    label: "Source token account"
+  });
+  const destinationTokenAccount = args.recipientTokenAccount ?? await deriveAssociatedTokenAccount({
+    owner: args.recipient,
+    mint: args.mint,
+    tokenProgramAddress: args.tokenProgramAddress
+  });
+  const destinationAccount = await fetchSplTokenAccountInfo(args.client, destinationTokenAccount);
+  const createDestinationTokenAccount = !destinationAccount && !args.recipientTokenAccount && !args.failIfAssociatedTokenAccountMissing;
+  if (!destinationAccount && args.recipientTokenAccount) {
+    throw errInvalidArgs(`Recipient token account ${destinationTokenAccount} was not found.`);
+  }
+  if (!destinationAccount && args.failIfAssociatedTokenAccountMissing) {
+    throw errInvalidArgs(
+      `Recipient associated token account ${destinationTokenAccount} does not exist. Omit --fail-if-associated-token-account-missing to create it automatically.`
+    );
+  }
+  if (destinationAccount) {
+    assertTokenAccountMatches({
+      account: destinationAccount,
+      expectedMint: args.mint,
+      ...args.recipientTokenAccount ? {} : { expectedOwner: args.recipient },
+      label: "Recipient token account"
+    });
+  }
+  const instructions = [];
+  if (createDestinationTokenAccount) {
+    instructions.push(buildCreateAssociatedTokenAccountIdempotentInstruction({
+      payer: { address: args.owner },
+      associatedTokenAccount: destinationTokenAccount,
+      owner: args.recipient,
+      mint: args.mint,
+      tokenProgramAddress: args.tokenProgramAddress
+    }));
+  }
+  instructions.push(buildSplTokenTransferCheckedInstruction({
+    sourceTokenAccount,
+    mint: args.mint,
+    destinationTokenAccount,
+    owner: { address: args.owner },
+    amount: args.amount,
+    decimals: args.decimals,
+    tokenProgramAddress: args.tokenProgramAddress
+  }));
+  return {
+    instructions,
+    mint: args.mint,
+    tokenProgramAddress: args.tokenProgramAddress,
+    sourceTokenAccount,
+    destinationTokenAccount,
+    createdDestinationTokenAccount: createDestinationTokenAccount,
+    decimals: args.decimals
+  };
+}
+async function submitSolanaInstructions(args) {
+  const result = await withSpinner(
+    "Sending transaction\u2026",
+    "Transaction submitted",
+    async () => {
+      if (args.signer.type === "session") {
+        return await buildAndSendSolanaTransactionWithSession({
+          client: args.client,
+          instructions: args.instructions,
+          session: args.signer.session,
+          authToken: args.signer.authToken,
+          sponsored: args.sponsored,
+          gasPolicyId: args.feePolicyId
+        });
+      }
+      return await buildAndSendSolanaTransaction({
+        client: args.client,
+        instructions: args.instructions,
+        senderKeyBytes: args.signer.keyBytes,
+        sponsored: args.sponsored,
+        gasPolicyId: args.feePolicyId
+      });
+    }
   );
+  return result;
+}
+function printNativeDryRun(args) {
   if (isJSONMode()) {
     printJSON({
-      from: result.fromAddress,
-      to: toArg,
-      amount: amountArg,
-      token: symbol,
-      network,
-      sponsored,
-      signature: result.signature,
-      status: confirmed ? "confirmed" : "pending"
+      dryRun: true,
+      action: "solana-send",
+      from: args.from,
+      to: args.to,
+      amount: args.amount,
+      token: args.symbol,
+      network: args.network,
+      sponsored: args.sponsored,
+      instructions: ["transferSol"]
     });
-  } else {
-    const pairs = [
-      ["From", result.fromAddress],
-      ["To", toArg],
-      ["Amount", green(`${amountArg} ${symbol}`)],
-      ["Network", network]
-    ];
-    if (sponsored) {
-      pairs.push(["Fee", green("Sponsored")]);
-    }
-    pairs.push(["Signature", result.signature]);
-    pairs.push(["Status", confirmed ? `${successBadge()} ${green("Confirmed")}` : "Pending"]);
-    printKeyValue(pairs);
+    return;
   }
+  const pairs = [
+    ["Dry Run", "yes"],
+    ["From", args.from],
+    ["To", args.to],
+    ["Amount", green(`${args.amount} ${args.symbol}`)],
+    ["Network", args.network],
+    ["Instructions", "transferSol"]
+  ];
+  if (args.sponsored) pairs.push(["Fee", green("Sponsored")]);
+  printKeyValue(pairs);
+}
+function printNativeResult(args) {
+  if (isJSONMode()) {
+    printJSON({
+      from: args.result.fromAddress,
+      to: args.to,
+      amount: args.amount,
+      token: args.symbol,
+      network: args.network,
+      sponsored: args.sponsored,
+      signature: args.result.signature,
+      status: args.status
+    });
+    return;
+  }
+  const pairs = [
+    ["From", args.result.fromAddress],
+    ["To", args.to],
+    ["Amount", green(`${args.amount} ${args.symbol}`)],
+    ["Network", args.network]
+  ];
+  if (args.sponsored) pairs.push(["Fee", green("Sponsored")]);
+  pairs.push(["Signature", args.result.signature]);
+  pairs.push(["Status", args.status === "confirmed" ? `${successBadge()} ${green("Confirmed")}` : "Pending"]);
+  printKeyValue(pairs);
+}
+function printSplDryRun(args) {
+  const instructions = args.plan.createdDestinationTokenAccount ? ["createAssociatedTokenAccountIdempotent", "transferChecked"] : ["transferChecked"];
+  if (isJSONMode()) {
+    printJSON({
+      dryRun: true,
+      action: "solana-send",
+      from: args.from,
+      to: args.to,
+      amount: args.amount,
+      token: args.plan.mint,
+      tokenAddress: args.plan.mint,
+      network: args.network,
+      sponsored: args.sponsored,
+      tokenProgramAddress: args.plan.tokenProgramAddress,
+      sourceTokenAccount: args.plan.sourceTokenAccount,
+      destinationTokenAccount: args.plan.destinationTokenAccount,
+      createdDestinationTokenAccount: args.plan.createdDestinationTokenAccount,
+      instructions
+    });
+    return;
+  }
+  const pairs = [
+    ["Dry Run", "yes"],
+    ["From", args.from],
+    ["To", args.to],
+    ["Amount", green(`${args.amount} ${args.plan.mint}`)],
+    ["Mint", args.plan.mint],
+    ["Source Token Account", args.plan.sourceTokenAccount],
+    ["Destination Token Account", args.plan.destinationTokenAccount],
+    ["Created Destination Token Account", args.plan.createdDestinationTokenAccount ? "yes" : "no"],
+    ["Network", args.network],
+    ["Instructions", instructions.join(", ")]
+  ];
+  if (args.sponsored) pairs.push(["Fee", green("Sponsored")]);
+  printKeyValue(pairs);
+}
+function printSplResult(args) {
+  if (isJSONMode()) {
+    printJSON({
+      from: args.result.fromAddress,
+      to: args.to,
+      amount: args.amount,
+      token: args.plan.mint,
+      tokenAddress: args.plan.mint,
+      network: args.network,
+      sponsored: args.sponsored,
+      tokenProgramAddress: args.plan.tokenProgramAddress,
+      sourceTokenAccount: args.plan.sourceTokenAccount,
+      destinationTokenAccount: args.plan.destinationTokenAccount,
+      createdDestinationTokenAccount: args.plan.createdDestinationTokenAccount,
+      signature: args.result.signature,
+      status: args.status
+    });
+    return;
+  }
+  const pairs = [
+    ["From", args.result.fromAddress],
+    ["To", args.to],
+    ["Amount", green(`${args.amount} ${args.plan.mint}`)],
+    ["Mint", args.plan.mint],
+    ["Source Token Account", args.plan.sourceTokenAccount],
+    ["Destination Token Account", args.plan.destinationTokenAccount],
+    ["Created Destination Token Account", args.plan.createdDestinationTokenAccount ? "yes" : "no"],
+    ["Network", args.network]
+  ];
+  if (args.sponsored) pairs.push(["Fee", green("Sponsored")]);
+  pairs.push(["Signature", args.result.signature]);
+  pairs.push(["Status", args.status === "confirmed" ? `${successBadge()} ${green("Confirmed")}` : "Pending"]);
+  printKeyValue(pairs);
 }
 async function resolveSolanaSigner(program2, signer) {
   if (signer === "session") {
@@ -4267,51 +4738,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}`
     );
@@ -4499,9 +4929,9 @@ async function debugRecoveredTypedDataAddress(args) {
 }
 function createDelegatedAccount(args) {
   const sessionBinding = buildSessionBindingInput(args.session);
-  const address2 = args.session.evmAddress;
+  const address3 = args.session.evmAddress;
   return toAccount({
-    address: address2,
+    address: address3,
     async signTransaction() {
       throw errInvalidArgs(
         "Delegated signer does not support direct transaction signing. Use wallet commands that execute through Alchemy smart wallets."
@@ -4532,7 +4962,7 @@ function createDelegatedAccount(args) {
         message: remoteMessage.message,
         encoding: remoteMessage.encoding,
         signature: signedMessage,
-        expectedAddress: address2
+        expectedAddress: address3
       });
       return signedMessage;
     },
@@ -4568,7 +4998,7 @@ function createDelegatedAccount(args) {
       await debugRecoveredTypedDataAddress({
         typedData: serializedTypedData,
         signature: typedDataSignature,
-        expectedAddress: address2
+        expectedAddress: address3
       });
       return typedDataSignature;
     },
@@ -5102,6 +5532,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 +6100,7 @@ function registerSolana(program2) {
   registerSolanaProgram(cmd);
   registerSolanaDelegate(cmd);
   registerStatus(cmd, { networkMode: "solana" });
+  registerSolanaRpcSurfaceCommands(program2, cmd);
   registerReservedSolanaCommands(cmd);
 }
 
@@ -5695,8 +6637,8 @@ function registrySymbolSuggestions(network) {
 }
 
 // src/commands/approve.ts
-function isNativeToken(address2) {
-  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
+function isNativeToken(address3) {
+  return address3.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
 function buildApprovalRequest(opts, tokenMeta) {
   validateApprovalMode(opts);
@@ -6368,18 +7310,18 @@ async function performContractCall(program2, addressArg, functionArg, opts) {
 // src/commands/balance.ts
 async function fetchBalance(program2, addressInput, blockParam) {
   const client = clientFromFlags(program2);
-  const address2 = await resolveAddress(addressInput, client);
+  const address3 = await resolveAddress(addressInput, client);
   const result = await withSpinner(
     "Fetching balance\u2026",
     "Balance fetched",
-    () => client.call("eth_getBalance", [address2, blockParam])
+    () => client.call("eth_getBalance", [address3, blockParam])
   );
   const wei = BigInt(result);
   const network = resolveNetwork(program2);
   const symbol = nativeTokenSymbol(network);
   if (isJSONMode()) {
     printJSON({
-      address: address2,
+      address: address3,
       wei: wei.toString(),
       balance: weiToEth(wei),
       symbol,
@@ -6387,7 +7329,7 @@ async function fetchBalance(program2, addressInput, blockParam) {
     });
   } else {
     printKeyValue([
-      ["Address", address2],
+      ["Address", address3],
       ["Balance", green(`${weiToEth(wei)} ${symbol}`)],
       ["Network", network]
     ]);
@@ -6395,7 +7337,7 @@ async function fetchBalance(program2, addressInput, blockParam) {
       console.log("");
       printJSON({
         rpcMethod: "eth_getBalance",
-        rpcParams: [address2, blockParam],
+        rpcParams: [address3, blockParam],
         rpcResult: result
       });
     }
@@ -6480,9 +7422,9 @@ Examples:
     try {
       const addressInput = addressArg ?? await readStdinArg("address");
       const client = clientFromFlags(program2);
-      const address2 = await resolveAddress(addressInput, client);
+      const address3 = await resolveAddress(addressInput, client);
       const params = {
-        owner: address2,
+        owner: address3,
         withMetadata: "true"
       };
       if (opts.limit) params.pageSize = String(opts.limit);
@@ -6516,7 +7458,7 @@ Examples:
           break;
         }
         const nextParams = {
-          owner: address2,
+          owner: address3,
           withMetadata: "true",
           pageKey
         };
@@ -6558,15 +7500,15 @@ Examples:
       exitWithError(err);
     }
   });
-  cmd.command("contract <address>").description("Get NFT contract metadata").action(async (address2) => {
+  cmd.command("contract <address>").description("Get NFT contract metadata").action(async (address3) => {
     try {
-      validateAddress(address2);
+      validateAddress(address3);
       const client = clientFromFlags(program2);
       const result = await withSpinner(
         "Fetching contract metadata\u2026",
         "Contract metadata fetched",
         () => client.callEnhanced("getContractMetadata", {
-          contractAddress: address2
+          contractAddress: address3
         })
       );
       if (isJSONMode()) printJSON(result);
@@ -6703,8 +7645,8 @@ Examples:
     try {
       const addressInput = addressArg ?? await readStdinArg("address");
       const client = clientFromFlags(program2);
-      const address2 = await resolveAddress(addressInput, client);
-      const params = [address2];
+      const address3 = await resolveAddress(addressInput, client);
+      const params = [address3];
       if (opts.pageKey) {
         params.push("erc20", { pageKey: opts.pageKey });
       }
@@ -6741,7 +7683,7 @@ Examples:
       }
       let totalShown = nonZero.length;
       printKeyValue([
-        ["Address", address2],
+        ["Address", address3],
         ["Network", client.network],
         ["Tokens", String(totalShown)]
       ]);
@@ -6767,7 +7709,7 @@ Examples:
         const nextResult = await withSpinner(
           "Fetching next page\u2026",
           "Page fetched",
-          () => client.call("alchemy_getTokenBalances", [address2, "erc20", { pageKey }])
+          () => client.call("alchemy_getTokenBalances", [address3, "erc20", { pageKey }])
         );
         if (isJSONMode()) {
           printJSON(nextResult);
@@ -6887,7 +7829,7 @@ Examples:
   ).action(async (addressArg, opts) => {
     try {
       const client = clientFromFlags(program2);
-      const address2 = addressArg ? await resolveAddress(addressArg, client) : void 0;
+      const address3 = addressArg ? await resolveAddress(addressArg, client) : void 0;
       if (opts.fromAddress) opts.fromAddress = await resolveAddress(opts.fromAddress, client);
       if (opts.toAddress) opts.toAddress = await resolveAddress(opts.toAddress, client);
       const baseFilter = {
@@ -6903,8 +7845,8 @@ Examples:
       }
       if (opts.pageKey) baseFilter.pageKey = opts.pageKey;
       const filter = { ...baseFilter };
-      if (address2 && !opts.fromAddress && !opts.toAddress) {
-        filter.fromAddress = address2;
+      if (address3 && !opts.fromAddress && !opts.toAddress) {
+        filter.fromAddress = address3;
       } else {
         if (opts.fromAddress) filter.fromAddress = opts.fromAddress;
         if (opts.toAddress) filter.toAddress = opts.toAddress;
@@ -7110,6 +8052,7 @@ function registerData(program2) {
   registerTransfers(cmd);
   registerPrices(cmd);
   registerPortfolio(cmd);
+  registerDataSurfaceCommands(program2, cmd);
 }
 
 // src/commands/debug.ts
@@ -7409,7 +8352,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:
@@ -7418,6 +8361,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 {
@@ -7437,6 +8383,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
@@ -7470,7 +8434,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);
     }
   });
@@ -7644,14 +8608,14 @@ import {
 // src/lib/wallet-quote-client.ts
 import { createClient } from "viem";
 import { parseAccount } from "viem/accounts";
-function buildWalletQuoteClient(program2, address2) {
+function buildWalletQuoteClient(program2, address3) {
   const apiKey = resolveAPIKey(program2);
   if (!apiKey) throw errAuthRequired();
   const cfg = load();
   const network = resolveNetwork(program2, cfg);
   const chain = networkToChain(network);
   const client = createClient({
-    account: parseAccount(address2),
+    account: parseAccount(address3),
     transport: createAlchemyWalletTransport(apiKey),
     chain,
     name: "alchemyQuoteClient"
@@ -7663,7 +8627,7 @@ function buildWalletQuoteClient(program2, address2) {
     client,
     network,
     chain,
-    address: address2,
+    address: address3,
     paymaster: void 0
   };
 }
@@ -7740,8 +8704,8 @@ function normalizeQuoteError(err, flow) {
 
 // src/commands/swap.ts
 var NATIVE_DECIMALS = 18;
-function isNativeToken2(address2) {
-  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
+function isNativeToken2(address3) {
+  return address3.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
 function slippagePercentToBasisPoints(percent) {
   return BigInt(Math.round(percent * 100));
@@ -8433,8 +9397,8 @@ import {
   swapActions as swapActions2
 } from "@alchemy/wallet-apis/experimental";
 var NATIVE_DECIMALS2 = 18;
-function isNativeToken3(address2) {
-  return address2.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
+function isNativeToken3(address3) {
+  return address3.toLowerCase() === NATIVE_TOKEN_ADDRESS.toLowerCase();
 }
 function slippagePercentToBasisPoints2(percent) {
   return BigInt(Math.round(percent * 100));
@@ -9387,7 +10351,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.2", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
+).version("0.10.0", "-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(
@@ -9574,11 +10538,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);
@@ -9613,7 +10577,7 @@ ${styledLine}`;
   if (isInteractiveAllowed(program)) {
     let latestForInteractiveStartup = null;
     if (shouldRunOnboarding(program, cfg)) {
-      const { runOnboarding } = await import("./onboarding-CW7XGRE4.js");
+      const { runOnboarding } = await import("./onboarding-A7IOH2MX.js");
       const latest = getAvailableUpdateOnce();
       const completed = await runOnboarding(program, latest);
       updateShownDuringInteractiveStartup = Boolean(latest);
@@ -9627,7 +10591,7 @@ ${styledLine}`;
         latestForInteractiveStartup
       );
     }
-    const { startREPL } = await import("./interactive-IBR6RN74.js");
+    const { startREPL } = await import("./interactive-D34T7RI6.js");
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {