@alchemy/cli 0.7.3 → 0.7.4-alpha.37

package/dist/index.js

@@ -2,26 +2,27 @@
 if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
 import {
   registerAuth
-} from "./chunk-XSN4XA5Z.js";
+} from "./chunk-2OUAYCVA.js";
 import {
   openBrowser
-} from "./chunk-C5HNQOLB.js";
+} from "./chunk-WCZIVY4O.js";
 import {
   SETUP_CAPABILITY_LABELS,
   SETUP_CAPABILITY_ORDER,
   getSetupStatus,
   isSetupComplete,
   shouldRunOnboarding
-} from "./chunk-R4W44A6E.js";
+} from "./chunk-UYZH6GSY.js";
 import {
   isInteractiveAllowed
-} from "./chunk-64A5W4M2.js";
+} from "./chunk-AUGBYMHT.js";
 import {
   adminClientFromFlags,
   clearSession,
   clientFromFlags,
   createPendingSession,
   getRPCNetworks,
+  getWalletSessionByChain,
   isSessionValid,
   isSolanaNetwork,
   loadSession,
@@ -43,12 +44,12 @@ import {
   resolveX402Client,
   saveSession,
   updateSession
-} from "./chunk-K6V3R7SH.js";
+} from "./chunk-5HYOZ773.js";
 import {
   getAvailableUpdate,
   getUpdateStatus,
   printUpdateNotice
-} from "./chunk-FD6YLNTB.js";
+} from "./chunk-6UHKZ5EN.js";
 import {
   bold,
   brand,
@@ -72,7 +73,7 @@ import {
   weiToEth,
   withSpinner,
   yellow
-} from "./chunk-5IL2PMZ6.js";
+} from "./chunk-HR2UZ6ZU.js";
 import {
   KEY_MAP,
   configDir,
@@ -83,7 +84,7 @@ import {
   save,
   toMap,
   validKeys
-} from "./chunk-JUCUKTP3.js";
+} from "./chunk-PX2YJ7XC.js";
 import {
   CLIError,
   EXIT_CODES,
@@ -119,7 +120,7 @@ import {
   setFlags,
   setNoColor,
   verbose
-} from "./chunk-2BALTY22.js";
+} from "./chunk-MYHXAACL.js";
 
 // src/index.ts
 import { Command, Help } from "commander";
@@ -626,7 +627,7 @@ function registerConfig(program2) {
       printJSON(toMap(cfg));
       return;
     }
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-WXT5ZCUK.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-PAQKIAX3.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 = [
@@ -1305,7 +1306,19 @@ var walletSessionCreateResponseSchema = z.object({
   approvalUrl: z.string().url(),
   expiresAt: z.string().datetime().optional()
 }).passthrough();
+var walletSessionRequestSessionCreateResponseSchema = z.object({
+  walletSessionId: z.string().min(1),
+  chainType: z.string().min(1),
+  status: rawWalletSessionStateSchema.transform(normalizeWalletSessionState)
+}).passthrough();
+var walletSessionRequestCreateResponseSchema = z.object({
+  sessionId: z.string().min(1),
+  approvalUrl: z.string().url(),
+  expiresAt: z.string().datetime().optional(),
+  sessions: z.array(walletSessionRequestSessionCreateResponseSchema).min(1)
+}).passthrough();
 var rawWalletSessionStatusResponseSchema = z.object({
+  type: z.literal("session").optional(),
   sessionId: z.string().min(1).optional(),
   status: rawWalletSessionStateSchema,
   expiresAt: z.string().datetime().optional(),
@@ -1321,6 +1334,15 @@ var rawWalletSessionStatusResponseSchema = z.object({
   chainType: z.string().min(1).optional(),
   capabilities: z.record(z.string(), z.boolean()).optional()
 }).passthrough();
+var walletSessionRequestStatusResponseSchema = z.object({
+  type: z.literal("sessionRequest"),
+  sessionId: z.string().min(1),
+  sessions: z.array(
+    rawWalletSessionStatusResponseSchema.extend({
+      walletSessionId: z.string().min(1)
+    })
+  ).min(1)
+}).passthrough();
 var walletSessionDisconnectResponseSchema = z.object({
   sessionId: z.string().min(1).optional(),
   status: rawWalletSessionStateSchema.optional().transform(
@@ -1347,9 +1369,14 @@ var rawEvmSigningChallengeResponseSchema = z.object({
   challenge: z.string().min(1),
   expiresAt: z.string().datetime(),
   requestExpiry: z.string().min(1),
-  method: z.enum(["personal_sign", "eth_signTypedData_v4", "eth_sign7702Authorization"]),
+  method: z.enum([
+    "personal_sign",
+    "eth_signTypedData_v4",
+    "eth_sign7702Authorization",
+    "signTransaction"
+  ]),
   walletId: z.string().min(1),
-  walletAddress: z.string().regex(/^0x[a-fA-F0-9]{40}$/),
+  walletAddress: z.string().min(1),
   providerKeyQuorumId: z.string().min(1).optional(),
   providerSignerId: z.string().min(1).optional()
 }).strict();
@@ -1375,6 +1402,10 @@ var signAuthorizationCompleteResponseSchema = z.object({
     y_parity: z.number().int()
   }).strict()
 }).strict();
+var solanaSignTransactionCompleteResponseSchema = z.object({
+  signedTransaction: z.string().min(1),
+  encoding: z.literal("base64")
+}).strict();
 function baseURLOverride() {
   const options = { allowedHostnames: [STAGING_ADMIN_API_HOST] };
   return parseBaseURLOverride(WALLET_API_BASE_URL_ENV, options) ?? parseBaseURLOverride(ADMIN_API_BASE_URL_ENV, options);
@@ -1468,6 +1499,17 @@ function normalizeWalletSessionStatus(session) {
     privySignerId: session.providerSignerId
   };
 }
+function normalizeWalletSessionRequestStatus(request2) {
+  return {
+    sessionId: request2.sessionId,
+    sessions: request2.sessions.map(({ walletSessionId, ...session }) => {
+      return normalizeWalletSessionStatus({
+        ...session,
+        sessionId: walletSessionId
+      });
+    })
+  };
+}
 function normalizeEvmSigningChallengeResponse(response) {
   return {
     ...response,
@@ -1483,7 +1525,15 @@ function toProviderSigningBindingInput(input) {
     ...privySignerId ? { providerSignerId: privySignerId } : {}
   };
 }
-async function createRemoteWalletSession(token, input) {
+function toProviderSolanaSigningBindingInput(input) {
+  const { privyKeyQuorumId, privySignerId, ...rest } = input;
+  return {
+    ...rest,
+    ...privyKeyQuorumId ? { providerKeyQuorumId: privyKeyQuorumId } : {},
+    ...privySignerId ? { providerSignerId: privySignerId } : {}
+  };
+}
+async function createRemoteWalletSessionRequest(token, input) {
   let data;
   let requestInput = input;
   for (let attempt = 0; attempt < 3; attempt += 1) {
@@ -1494,16 +1544,19 @@ async function createRemoteWalletSession(token, input) {
         "/wallet/sessions",
         requestInput
       );
-      return unwrapAdminData(walletSessionCreateResponseSchema, data);
+      return unwrapAdminData(walletSessionRequestCreateResponseSchema, data);
     } catch (err) {
-      const retryInput = getClientInstanceCompatibilityRetryInput(requestInput, err);
+      const retryInput = getClientInstanceCompatibilityRetryInput(
+        requestInput,
+        err
+      );
       if (retryInput === void 0) {
         throw err;
       }
       requestInput = retryInput;
     }
   }
-  throw new CLIError(ErrorCode.NETWORK_ERROR, "Unable to create wallet session.");
+  throw new CLIError(ErrorCode.NETWORK_ERROR, "Unable to create wallet session request.");
 }
 function getClientInstanceCompatibilityRetryInput(input, err) {
   if (input.environment.clientInstanceName !== void 0 && isUnsupportedClientInstanceMetadataError(err, "clientInstanceName")) {
@@ -1538,6 +1591,16 @@ async function getRemoteWalletSession(token, sessionId) {
     unwrapAdminData(rawWalletSessionStatusResponseSchema, data)
   );
 }
+async function getRemoteWalletSessionRequest(token, sessionId) {
+  const data = await request(
+    token,
+    "GET",
+    `/wallet/sessions/${encodeURIComponent(sessionId)}`
+  );
+  return normalizeWalletSessionRequestStatus(
+    unwrapAdminData(walletSessionRequestStatusResponseSchema, data)
+  );
+}
 async function disconnectRemoteWalletSession(token, sessionId) {
   try {
     const data = await request(
@@ -1616,6 +1679,24 @@ var signAuthorizationChallengeInputSchema = evmSigningSessionBindingBaseSchema.e
     executor: z.literal("self").optional()
   }).strict()
 }).strict().superRefine(ensureSessionSignerBinding);
+var solanaSigningSessionBindingBaseSchema = z.object({
+  sessionId: z.string().uuid(),
+  walletId: z.string().min(1),
+  walletAddress: z.string().min(1),
+  privyKeyQuorumId: z.string().min(1).optional(),
+  privySignerId: z.string().min(1).optional()
+});
+var solanaSignTransactionChallengeInputSchema = solanaSigningSessionBindingBaseSchema.extend({
+  transaction: z.string().min(1),
+  encoding: z.literal("base64")
+}).strict().superRefine((input, ctx) => {
+  if (!input.privyKeyQuorumId && !input.privySignerId) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "Provide privyKeyQuorumId or privySignerId."
+    });
+  }
+});
 async function createRemoteSignTypedDataChallenge(token, input) {
   const parsedInput = signTypedDataChallengeInputSchema.parse(input);
   return createEvmSigningChallenge(
@@ -1654,6 +1735,25 @@ async function completeRemoteSignAuthorizationChallenge(token, input) {
     adminApiResponseSchema(signAuthorizationCompleteResponseSchema).transform((resp) => resp.data)
   );
 }
+async function createRemoteSolanaSignTransactionChallenge(token, input) {
+  const parsedInput = solanaSignTransactionChallengeInputSchema.parse(input);
+  return createEvmSigningChallenge(
+    token,
+    "/wallet/solana/sign-transaction/challenge",
+    toProviderSolanaSigningBindingInput(parsedInput),
+    adminApiResponseSchema(rawEvmSigningChallengeResponseSchema).transform(
+      (resp) => normalizeEvmSigningChallengeResponse(resp.data)
+    )
+  );
+}
+async function completeRemoteSolanaSignTransactionChallenge(token, input) {
+  return completeEvmSigningChallenge(
+    token,
+    "/wallet/solana/sign-transaction/complete",
+    input,
+    adminApiResponseSchema(solanaSignTransactionCompleteResponseSchema).transform((resp) => resp.data)
+  );
+}
 
 // src/commands/wallet.ts
 import QRCode from "qrcode";
@@ -1664,6 +1764,9 @@ var DEFAULT_WALLET_CAPABILITIES = {
   "evm.signTypedData": true,
   "evm.signAuthorization": true
 };
+var DEFAULT_SOLANA_SESSION_CAPABILITIES = {
+  "solana.signTransaction": true
+};
 function createEvmWallet() {
   const privateKey = generatePrivateKey();
   const account = privateKeyToAccount(privateKey);
@@ -1787,7 +1890,13 @@ async function withApprovalInterruptHandler(args) {
     return await args.run(controller.signal);
   } catch (err) {
     if (isWalletConnectInterruptedError(err)) {
-      await disconnectRemoteWalletSession(args.authToken, args.sessionId).catch(() => void 0);
+      await Promise.all(
+        args.sessionIds.map(
+          (sessionId) => disconnectRemoteWalletSession(args.authToken, sessionId).catch(
+            () => void 0
+          )
+        )
+      );
       clearSession();
     }
     throw err;
@@ -1798,23 +1907,9 @@ async function withApprovalInterruptHandler(args) {
     }
   }
 }
-function isFutureIsoDate(value) {
-  const date = new Date(value);
-  if (Number.isNaN(date.getTime())) {
-    return false;
-  }
-  return date > /* @__PURE__ */ new Date();
-}
-function isActiveWalletSession(session, remoteStatus) {
-  if (!session) return false;
-  if (session.status !== "approved") return false;
-  if (!isFutureIsoDate(session.expiresAt)) return false;
-  if (remoteStatus && remoteStatus !== "approved") return false;
-  return true;
-}
-function deriveWalletStatus(session, remoteStatus) {
+function deriveWalletStatus(session) {
   if (!session) return "none";
-  if (isActiveWalletSession(session, remoteStatus)) return "active";
+  if (isSessionValid(session)) return "active";
   if (session.status === "pending") return "none";
   return "expired";
 }
@@ -1924,7 +2019,7 @@ function resolveQrAddress(args) {
 function missingQrWalletError(type, source) {
   if (source === "session") {
     return type === "solana" ? errInvalidArgs(
-      "The session wallet does not yet support Solana QR selection. Use `alchemy wallet use local` or configure a local Solana wallet with `alchemy wallet connect --mode local --chain solana`."
+      "No Solana session wallet is configured. Run `alchemy wallet connect --mode session --force`."
     ) : errNoActiveSession();
   }
   if (source === "local") {
@@ -1935,20 +2030,6 @@ function missingQrWalletError(type, source) {
 function indentBlock(text, prefix = "  ") {
   return text.split("\n").map((line) => line ? `${prefix}${line}` : line).join("\n");
 }
-function generateAndPersistWallet() {
-  const wallet = createEvmWallet();
-  const keyPath = persistWalletKey("wallet-key", wallet.privateKey, wallet.address);
-  const cfg = load();
-  save({ ...cfg, wallet_key_file: keyPath, wallet_address: wallet.address });
-  return { address: wallet.address, keyFile: keyPath };
-}
-async function generateAndPersistSolanaWallet() {
-  const wallet = await createSolanaWallet();
-  const keyPath = persistWalletKey("solana-wallet-key", wallet.secretKey, wallet.address);
-  const cfg = load();
-  save({ ...cfg, solana_wallet_key_file: keyPath, solana_wallet_address: wallet.address });
-  return { address: wallet.address, keyFile: keyPath };
-}
 async function createAndPersistWallets() {
   const evm = createEvmWallet();
   const solana = await createSolanaWallet();
@@ -2013,14 +2094,12 @@ function getEffectiveLocalWalletState(program2, cfg) {
 }
 async function runLocalCreate(opts) {
   const cfg = load();
-  const wantsEvm = opts.chain === "evm" || opts.chain === "both";
-  const wantsSolana = opts.chain === "solana" || opts.chain === "both";
-  const evmConflict = wantsEvm && Boolean(cfg.wallet_key_file);
-  const solanaConflict = wantsSolana && Boolean(cfg.solana_wallet_key_file);
+  const evmConflict = Boolean(cfg.wallet_key_file);
+  const solanaConflict = Boolean(cfg.solana_wallet_key_file);
   if ((evmConflict || solanaConflict) && !opts.force) {
     if (!isInteractiveAllowed(opts.program)) {
       throw errInvalidArgs(
-        "A local key is already configured for the selected chain. Re-run with --force to replace it."
+        "A local key is already configured. Re-run with --force to replace it."
       );
     }
     const kinds = [evmConflict ? "EVM" : null, solanaConflict ? "Solana" : null].filter(Boolean).join(" and ");
@@ -2033,16 +2112,7 @@ async function runLocalCreate(opts) {
       throw errInvalidArgs("Aborted. Existing local key preserved.");
     }
   }
-  if (opts.chain === "both") {
-    const { evm, solana: solana2 } = await createAndPersistWallets();
-    return { evm, solana: solana2 };
-  }
-  if (opts.chain === "evm") {
-    const evm = generateAndPersistWallet();
-    return { evm };
-  }
-  const solana = await generateAndPersistSolanaWallet();
-  return { solana };
+  return await createAndPersistWallets();
 }
 function runLocalImport(opts) {
   const cfg = load();
@@ -2075,7 +2145,27 @@ async function runLocalImportInteractive(opts) {
     return runLocalImport({ ...opts, force: true });
   }
 }
+function capabilitiesForChain(chain) {
+  return chain === "evm" ? { ...DEFAULT_WALLET_CAPABILITIES } : { ...DEFAULT_SOLANA_SESSION_CAPABILITIES };
+}
+function capabilitiesForChains(chains) {
+  return Object.fromEntries(
+    chains.map((chain) => [chain, capabilitiesForChain(chain)])
+  );
+}
+function getApprovedSessionWalletMetadata(chain, session) {
+  const walletId = chain === "evm" ? session.walletId ?? session.evmWalletId : session.solanaWalletId ?? session.walletId;
+  const walletAddress = chain === "evm" ? session.evmAddress ?? session.address : session.solanaAddress ?? session.address;
+  if (!walletId || !walletAddress) {
+    throw new CLIError(
+      ErrorCode.INTERNAL_ERROR,
+      "Approved wallet session response missing required metadata."
+    );
+  }
+  return { walletId, walletAddress };
+}
 async function runSessionConnect(opts) {
+  const requestedChains = ["evm", "solana"];
   const authToken = resolveAuthToken();
   if (!authToken) throw errAuthRequired();
   const existing = loadSession();
@@ -2113,32 +2203,51 @@ async function runSessionConnect(opts) {
     ...clientInstance.name === void 0 ? {} : { clientInstanceName: clientInstance.name }
   };
   updateSession({
-    chainType: "evm",
-    capabilities: { ...DEFAULT_WALLET_CAPABILITIES },
+    chainType: "both",
+    capabilities: Object.assign(
+      {},
+      ...requestedChains.map((chain) => capabilitiesForChain(chain))
+    ),
     backendBaseUrl: getWalletApiBaseUrl(),
     environment: sessionEnvironment
   });
-  const remoteSession = await createRemoteWalletSession(authToken, {
+  const remoteRequest = await createRemoteWalletSessionRequest(authToken, {
     publicKeyJwk: session.publicKeyJwk,
     requestSignerVersion: session.envelopeVersion,
-    chainType: "evm",
-    capabilities: { ...DEFAULT_WALLET_CAPABILITIES },
+    chains: requestedChains,
+    capabilities: capabilitiesForChains(requestedChains),
     environment: sessionEnvironment
   }).catch((err) => {
     clearSession();
     throw err;
   });
+  const pendingSessionsByChain = Object.fromEntries(
+    remoteRequest.sessions.map((remoteSession) => [
+      remoteSession.chainType,
+      {
+        sessionId: remoteSession.walletSessionId,
+        status: "pending",
+        expiresAt: remoteRequest.expiresAt ?? session.expiresAt,
+        chainType: remoteSession.chainType,
+        capabilities: capabilitiesForChain(
+          remoteSession.chainType
+        )
+      }
+    ])
+  );
   updateSession({
-    sessionId: remoteSession.sessionId,
-    expiresAt: remoteSession.expiresAt ?? session.expiresAt
+    connectionRequestId: remoteRequest.sessionId,
+    sessionId: remoteRequest.sessions[0].walletSessionId,
+    expiresAt: remoteRequest.expiresAt ?? session.expiresAt,
+    sessionsByChain: pendingSessionsByChain
   });
   if (!isJSONMode()) {
     const summaryPairs = [
-      ["Session ID", remoteSession.sessionId],
+      ["Connection Request ID", remoteRequest.sessionId],
       ["Status", "pending"],
-      ["Approval URL", remoteSession.approvalUrl],
+      ["Approval URL", remoteRequest.approvalUrl],
       ["Created", session.createdAt],
-      ["Expires", remoteSession.expiresAt ?? session.expiresAt]
+      ["Expires", remoteRequest.expiresAt ?? session.expiresAt]
     ];
     if (clientInstance.name !== void 0) {
       summaryPairs.splice(1, 0, ["Instance", clientInstance.name]);
@@ -2153,7 +2262,14 @@ async function runSessionConnect(opts) {
     });
     if (answer === null) {
       clearSession();
-      await disconnectRemoteWalletSession(authToken, remoteSession.sessionId).catch(() => void 0);
+      await Promise.all(
+        remoteRequest.sessions.map(
+          (remoteSession) => disconnectRemoteWalletSession(
+            authToken,
+            remoteSession.walletSessionId
+          ).catch(() => void 0)
+        )
+      );
       throw new WalletConnectInterruptedError();
     }
   }
@@ -2161,25 +2277,41 @@ async function runSessionConnect(opts) {
     console.log(`  Opening browser for approval...`);
     console.log(`  ${dim("Waiting for dashboard approval to complete connection.")}`);
   }
-  openBrowser(remoteSession.approvalUrl);
-  const approvedSession = await withApprovalInterruptHandler({
+  openBrowser(remoteRequest.approvalUrl);
+  const approvedSessions = await withApprovalInterruptHandler({
     authToken,
-    sessionId: remoteSession.sessionId,
+    sessionIds: remoteRequest.sessions.map(
+      (remoteSession) => remoteSession.walletSessionId
+    ),
     run: async (signal) => {
       const startedAt = Date.now();
       while (Date.now() - startedAt < CONNECT_TIMEOUT_MS) {
-        const current = await waitForInterruptible(
-          getRemoteWalletSession(authToken, remoteSession.sessionId),
+        const currentSessions = await waitForInterruptible(
+          remoteRequest.sessionId ? getRemoteWalletSessionRequest(
+            authToken,
+            remoteRequest.sessionId
+          ).then((request2) => request2.sessions) : Promise.all(
+            remoteRequest.sessions.map(
+              (remoteSession) => getRemoteWalletSession(authToken, remoteSession.walletSessionId)
+            )
+          ),
           signal
         );
-        if (current.status === "approved") {
-          return current;
+        if (requestedChains.every(
+          (chain) => currentSessions.some((current) => {
+            return current.chainType === chain && current.status === "approved";
+          })
+        )) {
+          return currentSessions;
         }
-        if (current.status === "denied" || current.status === "revoked" || current.status === "expired") {
+        const terminalSession = currentSessions.find((current) => {
+          return current.status === "denied" || current.status === "revoked" || current.status === "expired";
+        });
+        if (terminalSession) {
           clearSession();
           throw new CLIError(
             ErrorCode.INTERNAL_ERROR,
-            `Wallet session ${current.status}.`,
+            `Wallet session ${terminalSession.status}.`,
             "Run 'alchemy wallet connect' to start a new approval flow."
           );
         }
@@ -2188,58 +2320,123 @@ async function runSessionConnect(opts) {
       return null;
     }
   });
-  if (!approvedSession) {
+  if (!approvedSessions) {
     throw new CLIError(
       ErrorCode.NETWORK_ERROR,
       "Timed out waiting for wallet approval.",
       "Finish approval in the dashboard and rerun 'alchemy wallet connect --force' if needed."
     );
   }
-  const walletId = approvedSession.walletId ?? approvedSession.evmWalletId;
-  const evmAddress = approvedSession.evmAddress ?? approvedSession.address;
-  if (!approvedSession.privyAppId || !walletId || !evmAddress) {
+  const missingProviderAppId = approvedSessions.find((approvedSession) => {
+    return !approvedSession.privyAppId;
+  });
+  if (missingProviderAppId) {
     throw new CLIError(
       ErrorCode.INTERNAL_ERROR,
       "Approved wallet session response missing required metadata."
     );
   }
+  const approvedSessionsByChain = Object.fromEntries(
+    requestedChains.map((chain) => {
+      const approvedSession = approvedSessions.find((current) => {
+        return current.chainType === chain;
+      });
+      if (!approvedSession) {
+        throw new CLIError(
+          ErrorCode.INTERNAL_ERROR,
+          "Approved wallet session response missing requested chain."
+        );
+      }
+      const { walletId, walletAddress } = getApprovedSessionWalletMetadata(
+        chain,
+        approvedSession
+      );
+      return [
+        chain,
+        {
+          sessionId: approvedSession.sessionId ?? remoteRequest.sessions.find((remoteSession) => remoteSession.chainType === chain)?.walletSessionId ?? session.sessionId,
+          status: "approved",
+          expiresAt: approvedSession.expiresAt ?? remoteRequest.expiresAt ?? session.expiresAt,
+          chainType: chain,
+          walletId,
+          walletAddress,
+          providerKeyQuorumId: approvedSession.privyKeyQuorumId,
+          providerSignerId: approvedSession.privySignerId,
+          capabilities: approvedSession.capabilities ?? capabilitiesForChain(chain)
+        }
+      ];
+    })
+  );
+  const firstApprovedSession = approvedSessions.find((approvedSession) => {
+    return approvedSession.chainType === requestedChains[0];
+  }) ?? approvedSessions[0];
+  const evmSession = approvedSessionsByChain.evm;
+  const solanaSession = approvedSessionsByChain.solana;
   updateSession({
-    sessionId: approvedSession.sessionId ?? remoteSession.sessionId,
+    connectionRequestId: remoteRequest.sessionId,
+    sessionId: firstApprovedSession.sessionId ?? remoteRequest.sessions[0].walletSessionId,
     status: "approved",
-    expiresAt: approvedSession.expiresAt ?? remoteSession.expiresAt ?? session.expiresAt,
-    privyAppId: approvedSession.privyAppId,
-    walletId,
-    evmWalletId: approvedSession.evmWalletId ?? walletId,
-    evmAddress,
-    solanaWalletId: approvedSession.solanaWalletId,
-    solanaAddress: approvedSession.solanaAddress,
-    privyKeyQuorumId: approvedSession.privyKeyQuorumId,
-    privySignerId: approvedSession.privySignerId,
-    chainType: approvedSession.chainType ?? "evm",
-    capabilities: approvedSession.capabilities ?? { ...DEFAULT_WALLET_CAPABILITIES },
+    expiresAt: firstApprovedSession.expiresAt ?? remoteRequest.expiresAt ?? session.expiresAt,
+    privyAppId: firstApprovedSession.privyAppId,
+    walletId: evmSession?.walletId ?? solanaSession?.walletId,
+    evmWalletId: evmSession?.walletId,
+    evmAddress: evmSession?.walletAddress,
+    solanaWalletId: solanaSession?.walletId,
+    solanaAddress: solanaSession?.walletAddress,
+    privyKeyQuorumId: evmSession?.providerKeyQuorumId ?? solanaSession?.providerKeyQuorumId,
+    privySignerId: evmSession?.providerSignerId ?? solanaSession?.providerSignerId,
+    chainType: "both",
+    capabilities: Object.assign(
+      {},
+      ...requestedChains.map((chain) => capabilitiesForChain(chain)),
+      ...approvedSessions.map((approvedSession) => approvedSession.capabilities ?? {})
+    ),
+    sessionsByChain: approvedSessionsByChain,
     backendBaseUrl: getWalletApiBaseUrl(),
     environment: sessionEnvironment
   });
   if (isJSONMode()) {
     printJSON({
-      sessionId: approvedSession.sessionId ?? remoteSession.sessionId,
+      connectionRequestId: remoteRequest.sessionId,
+      sessionId: firstApprovedSession.sessionId ?? remoteRequest.sessions[0].walletSessionId,
+      walletSessionId: firstApprovedSession.sessionId ?? remoteRequest.sessions[0].walletSessionId,
       status: "approved",
-      privyAppId: approvedSession.privyAppId,
-      walletId,
-      evmAddress,
-      evmWalletId: approvedSession.evmWalletId ?? walletId,
-      chainType: approvedSession.chainType ?? "evm",
-      capabilities: approvedSession.capabilities ?? { ...DEFAULT_WALLET_CAPABILITIES },
-      expiresAt: approvedSession.expiresAt ?? remoteSession.expiresAt ?? session.expiresAt
+      privyAppId: firstApprovedSession.privyAppId,
+      walletId: evmSession?.walletId ?? solanaSession?.walletId,
+      ...evmSession ? {
+        evmAddress: evmSession.walletAddress,
+        evmWalletId: evmSession.walletId
+      } : {},
+      ...solanaSession ? {
+        solanaAddress: solanaSession.walletAddress,
+        solanaWalletId: solanaSession.walletId
+      } : {},
+      chainType: "both",
+      capabilities: Object.assign(
+        {},
+        ...requestedChains.map((chain) => capabilitiesForChain(chain))
+      ),
+      expiresAt: firstApprovedSession.expiresAt ?? remoteRequest.expiresAt ?? session.expiresAt,
+      sessionsByChain: approvedSessionsByChain
     });
   } else {
-    printKeyValue([
-      ["Session ID", approvedSession.sessionId ?? remoteSession.sessionId],
-      ["Status", green("approved")],
-      ["Wallet ID", walletId],
-      ["EVM Address", green(evmAddress)],
-      ["Expires", approvedSession.expiresAt ?? remoteSession.expiresAt ?? session.expiresAt]
+    const pairs = [
+      ["Connection Request ID", remoteRequest.sessionId],
+      ["Status", green("approved")]
+    ];
+    for (const chain of requestedChains) {
+      const chainSession = approvedSessionsByChain[chain];
+      if (!chainSession) continue;
+      pairs.push(
+        [`${chain.toUpperCase()} Wallet ID`, chainSession.walletId ?? ""],
+        [`${chain.toUpperCase()} Address`, green(chainSession.walletAddress ?? "")]
+      );
+    }
+    pairs.push([
+      "Expires",
+      firstApprovedSession.expiresAt ?? remoteRequest.expiresAt ?? session.expiresAt
     ]);
+    printKeyValue(pairs);
     console.log(`  ${green("\u2713")} Wallet connected`);
   }
 }
@@ -2308,17 +2505,6 @@ async function runConnectFlow(program2, opts) {
     }
     mode2 = "local";
   }
-  let chain = "both";
-  if (opts.chain !== void 0) {
-    if (opts.chain !== "evm" && opts.chain !== "solana" && opts.chain !== "both") {
-      throw errInvalidArgs("`--chain` must be 'evm', 'solana', or 'both'.");
-    }
-    chain = opts.chain;
-  }
-  if (importPath && chain !== "evm" && opts.chain !== void 0) {
-    throw errInvalidArgs("`--import` implies `--chain evm`; omit `--chain` or set it to 'evm'.");
-  }
-  if (importPath) chain = "evm";
   if (!mode2) {
     if (!isInteractiveAllowed(program2)) {
       throw errInvalidArgs(
@@ -2328,7 +2514,7 @@ async function runConnectFlow(program2, opts) {
     const choice = await promptSelect({
       message: "Choose a wallet to connect",
       options: [
-        { value: "session", label: "Session wallet", hint: "Recommended \u2014 Alchemy/Privy-managed, more secure" },
+        { 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",
@@ -2338,7 +2524,11 @@ async function runConnectFlow(program2, opts) {
     mode2 = choice;
   }
   if (mode2 === "session") {
-    await runSessionConnect({ program: program2, force, instanceName: opts.instanceName });
+    await runSessionConnect({
+      program: program2,
+      force,
+      instanceName: opts.instanceName
+    });
     printCrossModeHintAfterSessionConnect();
     return;
   }
@@ -2348,9 +2538,30 @@ async function runConnectFlow(program2, opts) {
     printCrossModeHintAfterLocal("evm");
     return;
   }
-  const result = await runLocalCreate({ chain, force, program: program2 });
+  const result = await runLocalCreate({ force, program: program2 });
   printPostLocalCreateSummary(result);
-  printCrossModeHintAfterLocal(chain);
+  printCrossModeHintAfterLocal("both");
+}
+function uniqueSessionIds(session) {
+  const ids = Object.values(session.sessionsByChain ?? {}).map((chainSession) => chainSession?.sessionId).filter((sessionId) => Boolean(sessionId));
+  if (ids.length === 0) {
+    ids.push(session.sessionId);
+  }
+  return Array.from(new Set(ids));
+}
+function selectRemoteSessionForStatus(session, remoteSessions) {
+  return remoteSessions.find((remoteSession) => {
+    return remoteSession.status !== "approved";
+  }) ?? remoteSessions.find((remoteSession) => {
+    return remoteSession.sessionId === session.sessionId;
+  }) ?? remoteSessions[0];
+}
+function mergeRemoteCapabilities(session, remoteSessions) {
+  return Object.assign(
+    {},
+    session.capabilities ?? {},
+    ...remoteSessions.map((remoteSession) => remoteSession.capabilities ?? {})
+  );
 }
 async function buildSessionSnapshot(program2, verify) {
   let session = loadStoredSession?.() ?? loadSession();
@@ -2358,25 +2569,55 @@ async function buildSessionSnapshot(program2, verify) {
   if (verify && session) {
     const authToken = resolveAuthToken();
     if (!authToken) throw errAuthRequired();
-    const remote = await getRemoteWalletSession(authToken, session.sessionId);
+    const remoteSessions = session.connectionRequestId ? await getRemoteWalletSessionRequest(authToken, session.connectionRequestId).then((request2) => request2.sessions) : await Promise.all(
+      uniqueSessionIds(session).map(
+        (sessionId) => getRemoteWalletSession(authToken, sessionId)
+      )
+    );
+    const remote = selectRemoteSessionForStatus(session, remoteSessions);
     remoteStatus = remote.status;
-    const walletId2 = remote.walletId ?? remote.evmWalletId;
+    const nextSessionsByChain = { ...session.sessionsByChain ?? {} };
+    for (const remoteSession of remoteSessions) {
+      const chain = remoteSession.chainType === "solana" ? "solana" : "evm";
+      const walletIdForChain = chain === "solana" ? remoteSession.solanaWalletId ?? remoteSession.walletId : remoteSession.evmWalletId ?? remoteSession.walletId;
+      const walletAddressForChain = chain === "solana" ? remoteSession.solanaAddress ?? remoteSession.address : remoteSession.evmAddress ?? remoteSession.address;
+      nextSessionsByChain[chain] = {
+        ...nextSessionsByChain[chain] ?? {},
+        sessionId: remoteSession.sessionId ?? nextSessionsByChain[chain]?.sessionId ?? session.sessionId,
+        status: normalizeRemoteStatusForStorage(remoteSession.status),
+        expiresAt: remoteSession.expiresAt ?? nextSessionsByChain[chain]?.expiresAt ?? session.expiresAt,
+        chainType: chain,
+        ...walletIdForChain ? { walletId: walletIdForChain } : {},
+        ...walletAddressForChain ? { walletAddress: walletAddressForChain } : {},
+        ...remoteSession.privyKeyQuorumId ? { providerKeyQuorumId: remoteSession.privyKeyQuorumId } : {},
+        ...remoteSession.privySignerId ? { providerSignerId: remoteSession.privySignerId } : {},
+        ...remoteSession.capabilities ? { capabilities: remoteSession.capabilities } : {}
+      };
+    }
+    const remoteChain = remote.chainType === "solana" ? "solana" : "evm";
+    const remoteWalletId = remoteChain === "solana" ? remote.solanaWalletId ?? remote.walletId : remote.evmWalletId ?? remote.walletId;
+    const evmWalletId = remoteChain === "evm" ? remoteWalletId ?? session.evmWalletId : session.evmWalletId;
+    const evmAddress = remoteChain === "evm" ? remote.evmAddress ?? remote.address ?? session.evmAddress : session.evmAddress;
+    const solanaWalletId = remoteChain === "solana" ? remoteWalletId ?? session.solanaWalletId : session.solanaWalletId;
+    const solanaAddress = remoteChain === "solana" ? remote.solanaAddress ?? remote.address ?? session.solanaAddress : session.solanaAddress;
+    const chainType = nextSessionsByChain.evm && nextSessionsByChain.solana ? "both" : remote.chainType ?? session.chainType;
     session = {
       ...session,
       status: normalizeRemoteStatusForStorage(remote.status),
       expiresAt: remote.expiresAt ?? session.expiresAt,
       privyAppId: remote.privyAppId ?? session.privyAppId,
-      walletId: walletId2 ?? session.walletId,
-      evmWalletId: remote.evmWalletId ?? walletId2 ?? session.evmWalletId,
-      evmAddress: remote.evmAddress ?? remote.address ?? session.evmAddress,
-      solanaWalletId: remote.solanaWalletId ?? session.solanaWalletId,
-      solanaAddress: remote.solanaAddress ?? session.solanaAddress,
-      chainType: remote.chainType ?? session.chainType,
-      capabilities: remote.capabilities ?? session.capabilities
+      walletId: evmWalletId ?? solanaWalletId ?? session.walletId,
+      evmWalletId,
+      evmAddress,
+      solanaWalletId,
+      solanaAddress,
+      chainType,
+      capabilities: mergeRemoteCapabilities(session, remoteSessions),
+      sessionsByChain: nextSessionsByChain
     };
     saveSession(session);
   }
-  const status = deriveWalletStatus(session, remoteStatus ?? void 0);
+  const status = deriveWalletStatus(session);
   const walletAddress = resolveSessionAddress(session);
   const environment = resolveSessionEnvironment(session);
   const signerCapabilities = resolveEnabledCapabilities(session);
@@ -2392,14 +2633,16 @@ async function buildSessionSnapshot(program2, verify) {
     walletId,
     expiresAt,
     sessionId: session?.sessionId ?? null,
+    connectionRequestId: session?.connectionRequestId ?? null,
     sessionState: session?.status ?? null,
     chainType: session?.chainType ?? null,
+    sessionsByChain: session?.sessionsByChain ?? null,
     valid: session ? isSessionValid(session) : false
   };
 }
 function registerWallets(program2) {
   const cmd = program2.command("wallet").description("Manage wallets");
-  cmd.command("connect").description("Connect a wallet for onchain actions (session or local)").option("--mode <mode>", "session | local").option("--chain <chain>", "For --mode local: evm | solana | both (default: both)").option("--import <path>", "For --mode local: import EVM key from file (implies --chain evm)").option("--instance-name <name>", "For --mode session: name this CLI instance").option("--force", "Replace the existing signer").action(async (opts) => {
+  cmd.command("connect").description("Connect a wallet for onchain actions (session or local)").option("--mode <mode>", "session | local").option("--import <path>", "For --mode local: import an EVM key from file instead of creating both wallets").option("--instance-name <name>", "For --mode session: name this CLI instance").option("--force", "Replace the existing signer").action(async (opts) => {
     try {
       await runConnectFlow(program2, opts);
     } catch (err) {
@@ -2429,10 +2672,12 @@ function registerWallets(program2) {
           expiresAt: snap.expiresAt,
           environment: snap.environment,
           signerCapabilities: snap.signerCapabilities,
+          connectionRequestId: snap.connectionRequestId,
           sessionId: snap.sessionId,
           sessionState: snap.sessionState,
           walletId: snap.walletId,
           chainType: snap.chainType,
+          sessionsByChain: snap.sessionsByChain,
           verified: Boolean(opts.verify),
           remoteStatus: snap.remoteStatus,
           valid: snap.valid,
@@ -2443,10 +2688,12 @@ function registerWallets(program2) {
             expiresAt: snap.expiresAt,
             environment: snap.environment,
             signerCapabilities: snap.signerCapabilities,
+            connectionRequestId: snap.connectionRequestId,
             sessionId: snap.sessionId,
             sessionState: snap.sessionState,
             walletId: snap.walletId,
             chainType: snap.chainType,
+            sessionsByChain: snap.sessionsByChain,
             valid: snap.valid
           },
           localEvm: localState.evmAddress ? { address: localState.evmAddress, keyFile: localState.evmKeyFile } : null,
@@ -2464,7 +2711,11 @@ function registerWallets(program2) {
         ["Environment", snap.environment ?? dim("none")],
         ["Signer Capabilities", snap.signerCapabilities.length > 0 ? snap.signerCapabilities.join(", ") : dim("none")]
       ];
-      if (snap.sessionId) pairs.push(["Session ID", snap.sessionId]);
+      if (snap.connectionRequestId) {
+        pairs.push(["Connection Request ID", snap.connectionRequestId]);
+      } else if (snap.sessionId) {
+        pairs.push(["Session ID", snap.sessionId]);
+      }
       if (snap.walletId) pairs.push(["Wallet ID", snap.walletId]);
       if (opts.verify) {
         pairs.push(["Backend Status", snap.remoteStatus ?? dim("not checked")]);
@@ -2619,7 +2870,7 @@ function registerWallets(program2) {
       }
       if (target === "local" && !hasLocalEvmKey()) {
         throw errInvalidArgs(
-          "No local EVM key configured. Run `alchemy wallet connect --mode local --chain evm` first."
+          "No local EVM key configured. Run `alchemy wallet connect --mode local` first."
         );
       }
       const cfg = load();
@@ -2634,8 +2885,11 @@ function registerWallets(program2) {
       exitWithError(err);
     }
   });
-  cmd.command("disconnect").description("Revoke the current wallet session").action(async () => {
+  cmd.command("disconnect").description("Revoke the current wallet session").option("--chain <chain>", "evm | solana").action(async (opts) => {
     try {
+      if (opts.chain !== void 0 && opts.chain !== "evm" && opts.chain !== "solana") {
+        throw errInvalidArgs("`--chain` must be 'evm' or 'solana'.");
+      }
       const session = loadStoredSession?.() ?? loadSession();
       if (!session) {
         if (isJSONMode()) {
@@ -2653,15 +2907,40 @@ function registerWallets(program2) {
       let revoked = false;
       let alreadyDisconnected = false;
       let remoteStatus = null;
+      const sessionsToDisconnect = opts.chain ? [
+        getWalletSessionByChain(
+          session,
+          opts.chain
+        )
+      ].filter(
+        (value) => value !== null
+      ) : Object.values(session.sessionsByChain ?? {}).filter(
+        (value) => value !== void 0
+      ).map(
+        (chainSession) => getWalletSessionByChain(session, chainSession.chainType)
+      ).filter(
+        (value) => value !== null
+      );
+      const disconnectTargets = sessionsToDisconnect.length > 0 ? sessionsToDisconnect : [session];
       if (authToken) {
-        const remote = await disconnectRemoteWalletSession(authToken, session.sessionId);
-        revoked = !remote.alreadyDisconnected;
-        alreadyDisconnected = remote.alreadyDisconnected;
-        remoteStatus = remote.status;
-      }
-      const removed = clearSession();
+        const results = await Promise.all(
+          disconnectTargets.map(
+            (target) => disconnectRemoteWalletSession(authToken, target.sessionId)
+          )
+        );
+        revoked = results.some((remote) => !remote.alreadyDisconnected);
+        alreadyDisconnected = results.every((remote) => remote.alreadyDisconnected);
+        remoteStatus = results[0]?.status ?? null;
+      }
+      const removed = opts.chain === void 0 ? clearSession() : updateSession({
+        sessionsByChain: {
+          ...session.sessionsByChain ?? {},
+          [opts.chain]: void 0
+        },
+        ...opts.chain === "evm" ? { evmWalletId: void 0, evmAddress: void 0 } : { solanaWalletId: void 0, solanaAddress: void 0 }
+      }) != null;
       const cfg = load();
-      if (cfg.active_signer === "session") {
+      if (cfg.active_signer === "session" && opts.chain !== "solana") {
         const { active_signer: _omit, ...rest } = cfg;
         save(rest);
       }
@@ -3056,9 +3335,10 @@ import {
   createKeyPairSignerFromBytes as createKeyPairSignerFromBytes2,
   createKeyPairSignerFromPrivateKeyBytes as createKeyPairSignerFromPrivateKeyBytes2
 } from "@solana/kit";
-import { getTransferSolInstruction } from "@solana-program/system";
+import { sign as signWithPrivateKey } from "crypto";
 var SOL_DECIMALS = 9;
 var SPONSOR_FEE_PAYER_PLACEHOLDER = address("Amh6quo1FcmL16Qmzdugzjq3Lv1zXzTW7ktswyLDzits");
+var SYSTEM_PROGRAM_ADDRESS = address("11111111111111111111111111111111");
 var SPL_TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
 function parseSolanaKeyBytes(secret) {
   const trimmed = secret.trim();
@@ -3089,11 +3369,28 @@ async function createSolanaSignerFromKeyBytes(keyBytes) {
   throw errInvalidArgs("Invalid Solana key: expected 64-byte secret key or 32-byte private key.");
 }
 function buildSolTransferInstruction(from, to, lamports) {
-  return getTransferSolInstruction({
-    source: from,
-    destination: to,
-    amount: lamports
-  });
+  return {
+    programAddress: SYSTEM_PROGRAM_ADDRESS,
+    accounts: [
+      { address: from.address, role: AccountRole.WRITABLE_SIGNER },
+      { address: to, role: AccountRole.WRITABLE }
+    ],
+    data: new Uint8Array([
+      ...encodeU32LE(2),
+      ...encodeU64LE(lamports)
+    ])
+  };
+}
+function encodeU32LE(value) {
+  if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+    throw errInvalidArgs("Instruction discriminator must fit in an unsigned 32-bit integer.");
+  }
+  const bytes = new Uint8Array(4);
+  bytes[0] = value & 255;
+  bytes[1] = value >> 8 & 255;
+  bytes[2] = value >> 16 & 255;
+  bytes[3] = value >> 24 & 255;
+  return bytes;
 }
 function encodeU64LE(value) {
   if (value < 0n || value > 0xffffffffffffffffn) {
@@ -3174,6 +3471,38 @@ async function buildAndSendSolanaTransaction(opts) {
   const signature = await client.call("sendTransaction", [wireTransaction, { encoding: "base64" }]);
   return { signature, fromAddress: signer.address };
 }
+async function buildAndSendSolanaTransactionWithSession(opts) {
+  const { client, instructions, session, authToken, sponsored, gasPolicyId } = opts;
+  const fromAddress = getSolanaSessionAddress(session);
+  const blockhashResult = await client.call("getLatestBlockhash", [{ commitment: "finalized" }]);
+  const { blockhash, lastValidBlockHeight } = blockhashResult.value;
+  const feePayer = sponsored ? SPONSOR_FEE_PAYER_PLACEHOLDER : address(fromAddress);
+  const txMessage = pipe(
+    createTransactionMessage({ version: 0 }),
+    (msg) => setTransactionMessageFeePayer(feePayer, msg),
+    (msg) => setTransactionMessageLifetimeUsingBlockhash(
+      { blockhash, lastValidBlockHeight },
+      msg
+    ),
+    (msg) => appendTransactionMessageInstructions(instructions, msg)
+  );
+  const compiledTx = compileTransaction(txMessage);
+  const transactionToSign = sponsored ? await sponsorSolanaTransaction({
+    client,
+    compiledTransactionBase64: getBase64EncodedWireTransaction(compiledTx),
+    gasPolicyId
+  }) : getBase64EncodedWireTransaction(compiledTx);
+  const signedTransaction = await signSolanaTransactionWithSession({
+    authToken,
+    session,
+    transactionBase64: transactionToSign
+  });
+  const signature = await client.call("sendTransaction", [
+    signedTransaction,
+    { encoding: "base64" }
+  ]);
+  return { signature, fromAddress };
+}
 async function waitForSolanaConfirmation(client, signature, timeoutMs = 6e4, pollIntervalMs = 2e3) {
   const start = Date.now();
   while (Date.now() - start < timeoutMs) {
@@ -3190,6 +3519,76 @@ async function waitForSolanaConfirmation(client, signature, timeoutMs = 6e4, pol
   }
   return false;
 }
+async function sponsorSolanaTransaction(args) {
+  if (!args.gasPolicyId) {
+    throw errInvalidArgs("Fee sponsorship requires a fee policy ID.");
+  }
+  const feePayerResponse = await args.client.call("alchemy_requestFeePayer", [{
+    policyId: args.gasPolicyId,
+    serializedTransaction: args.compiledTransactionBase64
+  }]);
+  return feePayerResponse.serializedTransaction;
+}
+async function signSolanaTransactionWithSession(args) {
+  const binding = getSolanaSessionBinding(args.session);
+  if (args.session.capabilities?.["solana.signTransaction"] === false) {
+    throw errInvalidArgs(
+      "Delegated wallet session does not allow 'solana.signTransaction'. Reconnect the wallet session to refresh capabilities."
+    );
+  }
+  const challenge = await createRemoteSolanaSignTransactionChallenge(args.authToken, {
+    ...binding,
+    transaction: args.transactionBase64,
+    encoding: "base64"
+  });
+  const completion = await completeRemoteSolanaSignTransactionChallenge(args.authToken, {
+    challengeId: challenge.challengeId,
+    signature: signChallengePayload({
+      challengePayload: challenge.challenge,
+      privateKeyPem: args.session.privateKeyPem
+    })
+  });
+  return completion.signedTransaction;
+}
+function getSolanaSessionBinding(session) {
+  const walletId = session.solanaWalletId ?? session.walletId;
+  const walletAddress = getSolanaSessionAddress(session);
+  if (!walletId) {
+    throw errInvalidArgs(
+      "Delegated wallet session is missing Solana wallet ID metadata. Run 'alchemy wallet connect --mode session --force'."
+    );
+  }
+  if (!session.privyKeyQuorumId && !session.privySignerId) {
+    throw errInvalidArgs(
+      "Delegated wallet session is missing signer binding metadata. Run 'alchemy wallet connect --mode session --force'."
+    );
+  }
+  return {
+    sessionId: session.sessionId,
+    walletId,
+    walletAddress,
+    privyKeyQuorumId: session.privyKeyQuorumId,
+    privySignerId: session.privySignerId
+  };
+}
+function getSolanaSessionAddress(session) {
+  if (!session.solanaAddress) {
+    throw errInvalidArgs(
+      "Delegated wallet session is missing Solana address metadata. Run 'alchemy wallet connect --mode session --force'."
+    );
+  }
+  return session.solanaAddress;
+}
+function signChallengePayload(args) {
+  return signWithPrivateKey(
+    "sha256",
+    Buffer.from(args.challengePayload, "utf8"),
+    {
+      key: args.privateKeyPem,
+      dsaEncoding: "der"
+    }
+  ).toString("base64url");
+}
 
 // src/lib/solana-fees.ts
 function resolveSolanaFeeSponsorship(program2) {
@@ -3211,23 +3610,54 @@ function parseDecimals(value) {
   }
   return decimals;
 }
-async function resolveLocalSolanaDelegateSigner(program2, signerOpt) {
+async function resolveSolanaDelegateSigner(program2, signerOpt) {
   const signer = parseSignerOpt(signerOpt);
   if (signer === "session") {
-    throw errInvalidArgs(
-      "The session wallet does not yet support Solana. Use `--signer local` or configure a local Solana wallet with `alchemy wallet connect --mode local --chain solana`."
-    );
+    return resolveSessionSolanaDelegateSigner();
+  }
+  if (signer === void 0 && resolveActiveSigner(program2) === "session") {
+    return resolveSessionSolanaDelegateSigner();
   }
   const solanaKey = resolveSolanaWalletKey(program2);
   if (!solanaKey) {
+    if (signer === void 0) {
+      const sessionSigner = tryResolveSessionSolanaDelegateSigner();
+      if (sessionSigner) {
+        return sessionSigner;
+      }
+    }
     throw errSolanaWalletKeyRequired();
   }
   const keyBytes = parseSolanaKeyBytes(solanaKey);
   return {
+    type: "local",
     keyBytes,
     signer: await createSolanaSignerFromKeyBytes(keyBytes)
   };
 }
+function resolveSessionSolanaDelegateSigner() {
+  const sessionSigner = tryResolveSessionSolanaDelegateSigner();
+  if (!sessionSigner) {
+    throw errInvalidArgs(
+      "No active Solana wallet session. Run `alchemy wallet connect --mode session` first."
+    );
+  }
+  return sessionSigner;
+}
+function tryResolveSessionSolanaDelegateSigner() {
+  const authToken = resolveAuthToken();
+  const session = resolveWalletSession();
+  const solanaSession = session ? getWalletSessionByChain(session, "solana") : null;
+  if (!authToken || !solanaSession?.solanaAddress) {
+    return void 0;
+  }
+  return {
+    type: "session",
+    address: solanaSession.solanaAddress,
+    session: solanaSession,
+    authToken
+  };
+}
 function registerSolanaDelegate(program2) {
   const cmd = program2.command("delegate").description("Delegate Solana token authority");
   const approveCmd = cmd.command("approve").description("Approve a delegate for an SPL token account").requiredOption("--token-account <address>", "SPL token account to delegate from").requiredOption("--mint <address>", "SPL token mint").requiredOption("--delegate <address>", "Delegate address").requiredOption("--amount <number>", "Amount to delegate in decimal token units").requiredOption("--decimals <n>", "Mint decimals").option("--fee-sponsored", "Enable Solana fee sponsorship").option("--fee-policy-id <id>", "Solana fee policy ID for sponsorship");
@@ -3261,7 +3691,7 @@ async function performSolanaDelegateApprove(program2, opts) {
   validateSolanaAddress(opts.delegate);
   const decimals = parseDecimals(opts.decimals);
   const rawAmount = parseAmount(opts.amount, decimals);
-  const { keyBytes, signer } = await resolveLocalSolanaDelegateSigner(program2, opts.signer);
+  const signer = await resolveSolanaDelegateSigner(program2, opts.signer);
   const network = resolveSolanaNetwork(program2);
   const { sponsored, feePolicyId } = resolveSolanaFeeSponsorship(program2);
   const client = clientFromFlags(program2, { forceNetwork: network });
@@ -3269,20 +3699,32 @@ async function performSolanaDelegateApprove(program2, opts) {
     tokenAccount: solAddress(opts.tokenAccount),
     mint: solAddress(opts.mint),
     delegate: solAddress(opts.delegate),
-    owner: signer,
+    owner: { address: solAddress(signer.type === "session" ? signer.address : signer.signer.address) },
     amount: rawAmount,
     decimals
   });
   const result = await withSpinner(
     "Approving delegate...",
     "Delegate approved",
-    () => buildAndSendSolanaTransaction({
-      client,
-      instructions: [instruction],
-      senderKeyBytes: keyBytes,
-      sponsored,
-      gasPolicyId: feePolicyId
-    })
+    async () => {
+      if (signer.type === "session") {
+        return await buildAndSendSolanaTransactionWithSession({
+          client,
+          instructions: [instruction],
+          session: signer.session,
+          authToken: signer.authToken,
+          sponsored,
+          gasPolicyId: feePolicyId
+        });
+      }
+      return await buildAndSendSolanaTransaction({
+        client,
+        instructions: [instruction],
+        senderKeyBytes: signer.keyBytes,
+        sponsored,
+        gasPolicyId: feePolicyId
+      });
+    }
   );
   const confirmed = await withSpinner(
     "Waiting for confirmation...",
@@ -3323,24 +3765,36 @@ async function performSolanaDelegateApprove(program2, opts) {
 }
 async function performSolanaDelegateRevoke(program2, opts) {
   validateSolanaAddress(opts.tokenAccount);
-  const { keyBytes, signer } = await resolveLocalSolanaDelegateSigner(program2, opts.signer);
+  const signer = await resolveSolanaDelegateSigner(program2, opts.signer);
   const network = resolveSolanaNetwork(program2);
   const { sponsored, feePolicyId } = resolveSolanaFeeSponsorship(program2);
   const client = clientFromFlags(program2, { forceNetwork: network });
   const instruction = buildSplTokenRevokeInstruction({
     tokenAccount: solAddress(opts.tokenAccount),
-    owner: signer
+    owner: { address: solAddress(signer.type === "session" ? signer.address : signer.signer.address) }
   });
   const result = await withSpinner(
     "Revoking delegate...",
     "Delegate revoked",
-    () => buildAndSendSolanaTransaction({
-      client,
-      instructions: [instruction],
-      senderKeyBytes: keyBytes,
-      sponsored,
-      gasPolicyId: feePolicyId
-    })
+    async () => {
+      if (signer.type === "session") {
+        return await buildAndSendSolanaTransactionWithSession({
+          client,
+          instructions: [instruction],
+          session: signer.session,
+          authToken: signer.authToken,
+          sponsored,
+          gasPolicyId: feePolicyId
+        });
+      }
+      return await buildAndSendSolanaTransaction({
+        client,
+        instructions: [instruction],
+        senderKeyBytes: signer.keyBytes,
+        sponsored,
+        gasPolicyId: feePolicyId
+      });
+    }
   );
   const confirmed = await withSpinner(
     "Waiting for confirmation...",
@@ -3584,35 +4038,41 @@ 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.");
   }
-  if (opts.signer === "session") {
-    throw errInvalidArgs(
-      "The session wallet does not yet support Solana. Use `--signer local` or configure a local Solana wallet with `alchemy wallet connect --mode local --chain solana`."
-    );
-  }
-  const solanaKey = resolveSolanaWalletKey(program2);
-  if (!solanaKey) {
-    throw errSolanaWalletKeyRequired();
-  }
-  const keyBytes = parseSolanaKeyBytes(solanaKey);
+  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 signer = await createSolanaSignerFromKeyBytes(keyBytes);
-  const instruction = buildSolTransferInstruction(signer, to, lamports);
+  const instruction = buildSolTransferInstruction(
+    { address: solAddress2(signer.address) },
+    to,
+    lamports
+  );
   const { sponsored, feePolicyId } = resolveSolanaFeeSponsorship(program2);
   const client = clientFromFlags(program2, { forceNetwork: network });
   const result = await withSpinner(
     "Sending transaction\u2026",
     "Transaction submitted",
-    () => buildAndSendSolanaTransaction({
-      client,
-      instructions: [instruction],
-      senderKeyBytes: keyBytes,
-      sponsored,
-      gasPolicyId: feePolicyId
-    })
+    async () => {
+      if (signer.type === "session") {
+        return await buildAndSendSolanaTransactionWithSession({
+          client,
+          instructions: [instruction],
+          session: signer.session,
+          authToken: signer.authToken,
+          sponsored,
+          gasPolicyId: feePolicyId
+        });
+      }
+      return await buildAndSendSolanaTransaction({
+        client,
+        instructions: [instruction],
+        senderKeyBytes: signer.keyBytes,
+        sponsored,
+        gasPolicyId: feePolicyId
+      });
+    }
   );
   const confirmed = await withSpinner(
     "Waiting for confirmation\u2026",
@@ -3645,6 +4105,70 @@ async function performSolanaSend(program2, toArg, amountArg, tokenAddress, opts
     printKeyValue(pairs);
   }
 }
+async function resolveSolanaSigner(program2, signer) {
+  if (signer === "session") {
+    const authToken = resolveAuthToken();
+    const session = resolveWalletSession();
+    const solanaSession = session ? getWalletSessionByChain(session, "solana") : null;
+    if (!authToken) {
+      throw errInvalidArgs("Session Solana signing requires CLI authentication.");
+    }
+    if (!solanaSession?.solanaAddress) {
+      throw errInvalidArgs(
+        "No active Solana wallet session. Run `alchemy wallet connect --mode session` first."
+      );
+    }
+    return {
+      type: "session",
+      address: solanaSession.solanaAddress,
+      session: solanaSession,
+      authToken
+    };
+  }
+  if (signer === void 0 && resolveActiveSigner(program2) === "session") {
+    const authToken = resolveAuthToken();
+    const session = resolveWalletSession();
+    const solanaSession = session ? getWalletSessionByChain(session, "solana") : null;
+    if (!authToken) {
+      throw errInvalidArgs("Session Solana signing requires CLI authentication.");
+    }
+    if (!solanaSession?.solanaAddress) {
+      throw errInvalidArgs(
+        "No active Solana wallet session. Run `alchemy wallet connect --mode session` first."
+      );
+    }
+    return {
+      type: "session",
+      address: solanaSession.solanaAddress,
+      session: solanaSession,
+      authToken
+    };
+  }
+  const solanaKey = resolveSolanaWalletKey(program2);
+  if (!solanaKey) {
+    if (signer === void 0) {
+      const authToken = resolveAuthToken();
+      const session = resolveWalletSession();
+      const solanaSession = session ? getWalletSessionByChain(session, "solana") : null;
+      if (authToken && solanaSession?.solanaAddress) {
+        return {
+          type: "session",
+          address: solanaSession.solanaAddress,
+          session: solanaSession,
+          authToken
+        };
+      }
+    }
+    throw errSolanaWalletKeyRequired();
+  }
+  const keyBytes = parseSolanaKeyBytes(solanaKey);
+  const localSigner = await createSolanaSignerFromKeyBytes(keyBytes);
+  return {
+    type: "local",
+    address: localSigner.address,
+    keyBytes
+  };
+}
 
 // src/lib/smart-wallet.ts
 import { createSmartWalletClient } from "@alchemy/wallet-apis";
@@ -3704,7 +4228,7 @@ function networkToChain(network) {
 }
 
 // src/lib/delegated-signer.ts
-import { sign as signWithPrivateKey } from "crypto";
+import { sign as signWithPrivateKey2 } from "crypto";
 import { isAddressEqual, recoverMessageAddress, recoverTypedDataAddress } from "viem";
 import { toAccount } from "viem/accounts";
 var messageCapabilities = {
@@ -3718,8 +4242,8 @@ function toHex(bytes) {
 function normalizeSignedChallengeSignature(signature) {
   return signature.toString("base64url");
 }
-function signChallengePayload(args) {
-  const signature = signWithPrivateKey(
+function signChallengePayload2(args) {
+  const signature = signWithPrivateKey2(
     "sha256",
     Buffer.from(args.challengePayload, "utf8"),
     {
@@ -3902,7 +4426,7 @@ function createDelegatedAccount(args) {
         message: remoteMessage.message,
         encoding: remoteMessage.encoding
       });
-      const signature = signChallengePayload({
+      const signature = signChallengePayload2({
         challengePayload: challenge.challenge,
         privateKeyPem: args.session.privateKeyPem
       });
@@ -3937,7 +4461,7 @@ function createDelegatedAccount(args) {
         ...sessionBinding,
         typedData: serializedTypedData
       });
-      const signature = signChallengePayload({
+      const signature = signChallengePayload2({
         challengePayload: challenge.challenge,
         privateKeyPem: args.session.privateKeyPem
       });
@@ -3966,7 +4490,7 @@ function createDelegatedAccount(args) {
         ...sessionBinding,
         authorization
       });
-      const signature = signChallengePayload({
+      const signature = signChallengePayload2({
         challengePayload: challenge.challenge,
         privateKeyPem: args.session.privateKeyPem
       });
@@ -4065,12 +4589,13 @@ function buildWalletClient(program2, options = {}) {
         }
         throw errNoActiveSession();
       }
-      assertSessionMetadata(validSession);
-      if (validSession.chainType && validSession.chainType !== "evm") {
+      const evmSession = getWalletSessionByChain(validSession, "evm");
+      if (!evmSession) {
         throw errInvalidArgs(
-          `Wallet session is configured for '${validSession.chainType}', not EVM. Run 'alchemy wallet connect --force'.`
+          "Wallet session is missing EVM metadata. Run 'alchemy wallet connect --mode session --force'."
         );
       }
+      assertSessionMetadata(evmSession);
       const authToken = resolveAuthToken(cfg);
       if (!authToken) {
         throw errAuthRequired();
@@ -4078,9 +4603,9 @@ function buildWalletClient(program2, options = {}) {
       return {
         signer: createDelegatedAccount({
           authToken,
-          session: validSession
+          session: evmSession
         }),
-        address: validSession.evmAddress
+        address: evmSession.evmAddress
       };
     }
     if (!localKey) throw errWalletKeyRequired();
@@ -4819,7 +5344,7 @@ function buildAgentPrompt(program2) {
         method: "Local wallet + API key",
         envVar: "ALCHEMY_WALLET_KEY",
         flag: "--wallet-key-file <path> | --signer local",
-        setup: "alchemy wallet connect --mode local --chain evm",
+        setup: "alchemy wallet connect --mode local",
         commandFamilies: [
           "evm send",
           "evm contract call",
@@ -6722,7 +7247,7 @@ Examples:
         dryRun: opts.dryRun
       });
     } catch (err) {
-      const { exitWithError: exitWithError2 } = await import("./errors-E2P6WHTX.js");
+      const { exitWithError: exitWithError2 } = await import("./errors-UL3W4ECQ.js");
       exitWithError2(err);
     }
   });
@@ -8298,7 +8823,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.7.3", "-v, --version", "display CLI version").option("--api-key <key>", "Alchemy API key (env: ALCHEMY_API_KEY)").option(
+).version("0.7.4-alpha.37", "-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(
@@ -8485,11 +9010,11 @@ ${styledLine}`;
     "wallet"
   ];
   if (!skipAppPrompt.includes(cmdName) && isInteractiveAllowed(program) && !opts.apiKey && !process.env.ALCHEMY_API_KEY) {
-    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-WXT5ZCUK.js");
+    const { resolveAuthToken: resolveAuthToken2 } = await import("./resolve-PAQKIAX3.js");
     const authToken = resolveAuthToken2(cfg);
     const hasApiKey = Boolean(cfg.api_key?.trim() || cfg.app?.apiKey);
     if (authToken && !hasApiKey) {
-      const { selectAppAfterAuth } = await import("./auth-F2IXC6CM.js");
+      const { selectAppAfterAuth } = await import("./auth-R5QHPFMA.js");
       console.log("");
       console.log(`  No app selected. Please select an app to continue.`);
       await selectAppAfterAuth(authToken);
@@ -8524,7 +9049,7 @@ ${styledLine}`;
   if (isInteractiveAllowed(program)) {
     let latestForInteractiveStartup = null;
     if (shouldRunOnboarding(program, cfg)) {
-      const { runOnboarding } = await import("./onboarding-TTUVIXM4.js");
+      const { runOnboarding } = await import("./onboarding-Q5PBXH3M.js");
       const latest = getAvailableUpdateOnce();
       const completed = await runOnboarding(program, latest);
       updateShownDuringInteractiveStartup = Boolean(latest);
@@ -8538,7 +9063,7 @@ ${styledLine}`;
         latestForInteractiveStartup
       );
     }
-    const { startREPL } = await import("./interactive-BNIJYEOV.js");
+    const { startREPL } = await import("./interactive-Z2YHE6ME.js");
     program.exitOverride();
     program.configureOutput({
       writeErr: () => {