@alchemy/cli 0.9.3 → 0.10.0

package/README.md

@@ -137,7 +137,8 @@ Per-command override: pass `--signer <session\|local>` to `evm send`, `evm appro
 | `solana rpc <method> [params...]` | Calls Solana JSON-RPC methods | `alchemy solana rpc getBalance '"<pubkey>"'` |
 | `solana das <method> [params...]` | Calls Solana DAS methods | `alchemy solana das getAssetsByOwner '{"ownerAddress":"<pubkey>"}'` |
 | `solana network list` | Lists networks from the Solana namespace | `alchemy solana network list --search solana` |
-| `solana send <to> <amount>` | Sends SOL to an address | `alchemy solana send <pubkey> 0.1` |
+| `solana send <to> <amount>` | Sends SOL or SPL tokens to an address | `alchemy solana send <pubkey> 0.1` |
+| `solana send <to> <amount> --token <mint>` | Sends an SPL token and creates the recipient ATA if needed | `alchemy solana send <pubkey> 10 --token <mint>` |
 | `solana program accounts/account/show` | Inspects Solana program accounts and account metadata | `alchemy solana program accounts <program-id>` |
 | `solana delegate approve/revoke` | Approves or revokes SPL token delegates | `alchemy solana delegate approve --token-account <addr> --mint <mint> --delegate <addr> --amount 1 --decimals 6` |
 | `solana status [id]` | Checks Solana transaction or operation status | `alchemy solana status <signature>` |
@@ -254,7 +255,7 @@ Additional env vars:
 | `wallet connect` | `--mode <session\|local>`, `--chain <evm\|solana\|both>`, `--import <path>`, `--instance-name <name>`, `--force` |
 | `wallet status` | `--verify` |
 | `wallet qr` | `--type <evm\|solana>`, `--solana` |
-| `solana send` | `--fee-sponsored`, `--fee-policy-id <id>`, `--signer <local>` (session signing is not yet supported for Solana) |
+| `solana send` | `--token <mint>`, `--dry-run`, `--fail-if-associated-token-account-missing`, `--from-token-account <address>`, `--recipient-token-account <address>`, `--fee-sponsored`, `--fee-policy-id <id>`, `--signer <session\|local>` |
 | `solana program accounts` | `--filters <json>`, `--encoding <encoding>`, `--limit <n>` |
 | `solana delegate approve` | `--token-account <address>`, `--mint <address>`, `--delegate <address>`, `--amount <number>`, `--decimals <n>`, `--fee-sponsored`, `--fee-policy-id <id>` |
 | `solana delegate revoke` | `--token-account <address>`, `--fee-sponsored`, `--fee-policy-id <id>` |

package/dist/{chunk-NUSUQI7X.js → chunk-HRWD4V2P.js}

@@ -53,7 +53,7 @@ function semverLT(a, b) {
   return false;
 }
 function currentVersion() {
-  return true ? "0.9.3" : "0.0.0";
+  return true ? "0.10.0" : "0.0.0";
 }
 function toUpdateStatus(latestVersion, checkedAt) {
   const current = currentVersion();

package/dist/index.js

@@ -65,7 +65,7 @@ import {
   getAvailableUpdate,
   getUpdateStatus,
   printUpdateNotice
-} from "./chunk-NUSUQI7X.js";
+} from "./chunk-HRWD4V2P.js";
 import {
   bold,
   brand,
@@ -222,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
@@ -267,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.`
     );
   }
 }
@@ -2034,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;
@@ -2152,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();
@@ -2596,21 +2596,20 @@ async function runConnectFlow(program2, opts) {
   }
   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();
-    mode = choice;
   }
   if (mode === "session") {
     await runSessionConnect({
@@ -4127,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);
@@ -4144,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") {
@@ -4466,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."
@@ -4499,7 +4962,7 @@ function createDelegatedAccount(args) {
         message: remoteMessage.message,
         encoding: remoteMessage.encoding,
         signature: signedMessage,
-        expectedAddress: address2
+        expectedAddress: address3
       });
       return signedMessage;
     },
@@ -4535,7 +4998,7 @@ function createDelegatedAccount(args) {
       await debugRecoveredTypedDataAddress({
         typedData: serializedTypedData,
         signature: typedDataSignature,
-        expectedAddress: address2
+        expectedAddress: address3
       });
       return typedDataSignature;
     },
@@ -6174,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);
@@ -6847,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,
@@ -6866,7 +7329,7 @@ async function fetchBalance(program2, addressInput, blockParam) {
     });
   } else {
     printKeyValue([
-      ["Address", address2],
+      ["Address", address3],
       ["Balance", green(`${weiToEth(wei)} ${symbol}`)],
       ["Network", network]
     ]);
@@ -6874,7 +7337,7 @@ async function fetchBalance(program2, addressInput, blockParam) {
       console.log("");
       printJSON({
         rpcMethod: "eth_getBalance",
-        rpcParams: [address2, blockParam],
+        rpcParams: [address3, blockParam],
         rpcResult: result
       });
     }
@@ -6959,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);
@@ -6995,7 +7458,7 @@ Examples:
           break;
         }
         const nextParams = {
-          owner: address2,
+          owner: address3,
           withMetadata: "true",
           pageKey
         };
@@ -7037,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);
@@ -7182,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 });
       }
@@ -7220,7 +7683,7 @@ Examples:
       }
       let totalShown = nonZero.length;
       printKeyValue([
-        ["Address", address2],
+        ["Address", address3],
         ["Network", client.network],
         ["Tokens", String(totalShown)]
       ]);
@@ -7246,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);
@@ -7366,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 = {
@@ -7382,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;
@@ -8145,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"
@@ -8164,7 +8627,7 @@ function buildWalletQuoteClient(program2, address2) {
     client,
     network,
     chain,
-    address: address2,
+    address: address3,
     paymaster: void 0
   };
 }
@@ -8241,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));
@@ -8934,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));
@@ -9888,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.3", "-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(
@@ -10114,7 +10577,7 @@ ${styledLine}`;
   if (isInteractiveAllowed(program)) {
     let latestForInteractiveStartup = null;
     if (shouldRunOnboarding(program, cfg)) {
-      const { runOnboarding } = await import("./onboarding-IJQ72DK7.js");
+      const { runOnboarding } = await import("./onboarding-A7IOH2MX.js");
       const latest = getAvailableUpdateOnce();
       const completed = await runOnboarding(program, latest);
       updateShownDuringInteractiveStartup = Boolean(latest);
@@ -10128,7 +10591,7 @@ ${styledLine}`;
         latestForInteractiveStartup
       );
     }
-    const { startREPL } = await import("./interactive-KLVEYTQM.js");
+    const { startREPL } = await import("./interactive-D34T7RI6.js");
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {

package/dist/{interactive-KLVEYTQM.js → interactive-D34T7RI6.js}

@@ -9,7 +9,7 @@ import {
 } from "./chunk-ANONMDDZ.js";
 import {
   getUpdateNoticeLines
-} from "./chunk-NUSUQI7X.js";
+} from "./chunk-HRWD4V2P.js";
 import {
   bold,
   brand,

package/dist/{onboarding-IJQ72DK7.js → onboarding-A7IOH2MX.js}

@@ -2,7 +2,7 @@
 if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
 import {
   getUpdateNoticeLines
-} from "./chunk-NUSUQI7X.js";
+} from "./chunk-HRWD4V2P.js";
 import {
   bold,
   brand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alchemy/cli",
-  "version": "0.9.3",
+  "version": "0.10.0",
   "description": "Alchemy CLI — interact with blockchain data",
   "type": "module",
   "bin": {