@alchemy/cli 0.6.1 → 0.6.3-alpha.6

package/dist/{chunk-ATX65U7J.js → chunk-PKAN5FKD.js}

@@ -1,12 +1,10 @@
 #!/usr/bin/env node
 if(process.argv.includes("--no-color"))process.env.NO_COLOR="1";
 import {
-  getCredentials
-} from "./chunk-JQRGILIS.js";
-import {
+  configDir,
   load,
   save
-} from "./chunk-BAAQ7ELR.js";
+} from "./chunk-B3R6PRAL.js";
 import {
   CLIError,
   ErrorCode,
@@ -31,10 +29,10 @@ import {
   parseBaseURLOverride,
   redactSensitiveText,
   verbose
-} from "./chunk-56ZVYB4G.js";
+} from "./chunk-QEDAULQ2.js";
 
 // src/lib/resolve.ts
-import { readFileSync } from "fs";
+import { readFileSync as readFileSync2 } from "fs";
 
 // src/lib/client.ts
 var Client = class _Client {
@@ -58,12 +56,12 @@ var Client = class _Client {
       parsed = new URL(`https://${hostname}`);
     } catch {
       throw errInvalidArgs(
-        `Unknown network '${network}'. Run 'alchemy network list' to see available networks.`
+        `Unknown network '${network}'. Run 'alchemy evm network list' to see available networks.`
       );
     }
     if (!parsed.hostname.endsWith(`.g.${domain}`)) {
       throw errInvalidArgs(
-        `Unknown network '${network}'. Run 'alchemy network list' to see available networks.`
+        `Unknown network '${network}'. Run 'alchemy evm network list' to see available networks.`
       );
     }
   }
@@ -413,6 +411,7 @@ var X402Client = class _X402Client {
 };
 
 // src/lib/admin-client.ts
+var STAGING_ADMIN_API_HOST = "admin-api.alchemypreview.com";
 var AdminClient = class _AdminClient {
   static get ADMIN_API_HOST() {
     return `admin-api.${getBaseDomain()}`;
@@ -448,7 +447,9 @@ var AdminClient = class _AdminClient {
     return isLocalhost(hostname);
   }
   baseURLOverride() {
-    return parseBaseURLOverride(_AdminClient.ADMIN_API_BASE_URL_ENV);
+    return parseBaseURLOverride(_AdminClient.ADMIN_API_BASE_URL_ENV, {
+      allowedHostnames: [STAGING_ADMIN_API_HOST]
+    });
   }
   validateAccessKey(accessKey) {
     if (!accessKey.trim() || /\s/.test(accessKey)) {
@@ -592,9 +593,429 @@ var AdminClient = class _AdminClient {
   }
 };
 
+// src/lib/networks.ts
+var TESTNET_TOKEN_RE = /(testnet|sepolia|holesky|hoodi|devnet|minato|amoy|fuji|saigon|cardona|aeneid|curtis|chiado|cassiopeia|blaze|ropsten|signet|mocha|fam|bepolia)$/i;
+var FAMILY_ALIASES = {
+  arb: "Arbitrum",
+  arbnova: "Arbitrum Nova",
+  avax: "Avalanche",
+  bnb: "BNB Smart Chain",
+  eth: "Ethereum",
+  opt: "OP Mainnet",
+  polygonzkevm: "Polygon zkEVM"
+};
+var NAME_ALIASES = {
+  arb: "Arbitrum",
+  avax: "Avalanche",
+  bnb: "BNB",
+  eth: "Ethereum",
+  opbnb: "opBNB",
+  opt: "OP Mainnet",
+  sui: "SUI",
+  xmtp: "XMTP",
+  zksync: "ZKsync"
+};
+var RPC_NETWORK_IDS = [
+  "abstract-mainnet",
+  "abstract-testnet",
+  "adi-mainnet",
+  "adi-testnet",
+  "alchemy-internal",
+  "alchemy-sepolia",
+  "alchemyarb-fam",
+  "alchemyarb-sepolia",
+  "alterscope-mainnet",
+  "anime-mainnet",
+  "anime-sepolia",
+  "apechain-curtis",
+  "apechain-mainnet",
+  "aptos-mainnet",
+  "aptos-testnet",
+  "arb-mainnet",
+  "arb-sepolia",
+  "arbnova-mainnet",
+  "arc-testnet",
+  "astar-mainnet",
+  "avax-fuji",
+  "avax-mainnet",
+  "base-mainnet",
+  "base-sepolia",
+  "berachain-bepolia",
+  "berachain-mainnet",
+  "bitcoin-mainnet",
+  "bitcoin-signet",
+  "bitcoin-testnet",
+  "blast-mainnet",
+  "blast-sepolia",
+  "bnb-mainnet",
+  "bnb-testnet",
+  "bob-mainnet",
+  "bob-sepolia",
+  "boba-mainnet",
+  "boba-sepolia",
+  "botanix-mainnet",
+  "botanix-testnet",
+  "celestiabridge-mainnet",
+  "celestiabridge-mocha",
+  "celo-mainnet",
+  "celo-sepolia",
+  "citrea-mainnet",
+  "citrea-testnet",
+  "clankermon-mainnet",
+  "commons-mainnet",
+  "crossfi-mainnet",
+  "crossfi-testnet",
+  "degen-mainnet",
+  "degen-sepolia",
+  "earnm-mainnet",
+  "earnm-sepolia",
+  "edge-mainnet",
+  "edge-testnet",
+  "eth-holesky",
+  "eth-holeskybeacon",
+  "eth-hoodi",
+  "eth-hoodibeacon",
+  "eth-mainnet",
+  "eth-mainnetbeacon",
+  "eth-sepolia",
+  "eth-sepoliabeacon",
+  "flow-mainnet",
+  "flow-testnet",
+  "frax-hoodi",
+  "frax-mainnet",
+  "galactica-cassiopeia",
+  "galactica-mainnet",
+  "gensyn-mainnet",
+  "gensyn-testnet",
+  "gnosis-chiado",
+  "gnosis-mainnet",
+  "humanity-mainnet",
+  "humanity-testnet",
+  "hyperliquid-mainnet",
+  "hyperliquid-testnet",
+  "ink-mainnet",
+  "ink-sepolia",
+  "lens-mainnet",
+  "lens-sepolia",
+  "linea-mainnet",
+  "linea-sepolia",
+  "mantle-mainnet",
+  "mantle-sepolia",
+  "megaeth-mainnet",
+  "megaeth-testnet",
+  "metis-mainnet",
+  "mode-mainnet",
+  "mode-sepolia",
+  "monad-mainnet",
+  "monad-testnet",
+  "moonbeam-mainnet",
+  "mythos-mainnet",
+  "opbnb-mainnet",
+  "opbnb-testnet",
+  "openloot-sepolia",
+  "opt-mainnet",
+  "opt-sepolia",
+  "plasma-mainnet",
+  "plasma-testnet",
+  "polygon-amoy",
+  "polygon-mainnet",
+  "polygonzkevm-cardona",
+  "polygonzkevm-mainnet",
+  "polynomial-mainnet",
+  "polynomial-sepolia",
+  "race-mainnet",
+  "race-sepolia",
+  "risa-testnet",
+  "rise-testnet",
+  "ronin-mainnet",
+  "ronin-saigon",
+  "rootstock-mainnet",
+  "rootstock-testnet",
+  "scroll-mainnet",
+  "scroll-sepolia",
+  "sei-mainnet",
+  "sei-testnet",
+  "settlus-mainnet",
+  "settlus-septestnet",
+  "shape-mainnet",
+  "shape-sepolia",
+  "solana-devnet",
+  "solana-mainnet",
+  "soneium-mainnet",
+  "soneium-minato",
+  "sonic-blaze",
+  "sonic-mainnet",
+  "sonic-testnet",
+  "stable-mainnet",
+  "stable-testnet",
+  "standard-mainnet",
+  "starknet-mainnet",
+  "starknet-sepolia",
+  "story-aeneid",
+  "story-mainnet",
+  "sui-mainnet",
+  "sui-testnet",
+  "superseed-mainnet",
+  "superseed-sepolia",
+  "synd-mainnet",
+  "syndicate-manchego",
+  "tea-sepolia",
+  "tempo-testnet",
+  "tron-mainnet",
+  "tron-testnet",
+  "unichain-mainnet",
+  "unichain-sepolia",
+  "unite-mainnet",
+  "unite-testnet",
+  "worldchain-mainnet",
+  "worldchain-sepolia",
+  "worldl3-devnet",
+  "worldmobile-devnet",
+  "worldmobile-testnet",
+  "worldmobilechain-mainnet",
+  "xmtp-mainnet",
+  "xmtp-ropsten",
+  "xprotocol-mainnet",
+  "zetachain-mainnet",
+  "zetachain-testnet",
+  "zksync-mainnet",
+  "zksync-sepolia",
+  "zora-mainnet",
+  "zora-sepolia"
+];
+function isTestnetNetwork(id) {
+  return TESTNET_TOKEN_RE.test(id);
+}
+function tokenToName(token) {
+  const alias = NAME_ALIASES[token];
+  if (alias) return alias;
+  return token.charAt(0).toUpperCase() + token.slice(1);
+}
+function toFamily(id) {
+  const [head] = id.split("-");
+  return FAMILY_ALIASES[head] ?? tokenToName(head);
+}
+function toDisplayName(id) {
+  return id.split("-").map((part) => tokenToName(part)).join(" ");
+}
+function toHttpsUrlTemplate(id) {
+  const domain = getBaseDomain();
+  if (id === "starknet-mainnet" || id === "starknet-sepolia") {
+    return `https://${id}.g.${domain}/starknet/version/rpc/v0_10/{apiKey}`;
+  }
+  return `https://${id}.g.${domain}/v2/{apiKey}`;
+}
+function getRPCNetworks() {
+  return RPC_NETWORK_IDS.map((id) => ({
+    id,
+    name: toDisplayName(id),
+    family: toFamily(id),
+    isTestnet: isTestnetNetwork(id),
+    httpsUrlTemplate: toHttpsUrlTemplate(id)
+  }));
+}
+function getRPCNetworkIds() {
+  return [...RPC_NETWORK_IDS];
+}
+var NATIVE_TOKEN_SYMBOLS = {
+  eth: "ETH",
+  arb: "ETH",
+  arbnova: "ETH",
+  opt: "ETH",
+  base: "ETH",
+  zksync: "ETH",
+  scroll: "ETH",
+  blast: "ETH",
+  linea: "ETH",
+  zora: "ETH",
+  shape: "ETH",
+  polygon: "POL",
+  polygonzkevm: "ETH",
+  bnb: "BNB",
+  opbnb: "BNB",
+  avax: "AVAX",
+  solana: "SOL",
+  starknet: "ETH",
+  fantom: "FTM",
+  metis: "METIS",
+  mantle: "MNT",
+  celo: "CELO",
+  gnosis: "xDAI",
+  frax: "frxETH",
+  worldchain: "ETH",
+  berachain: "BERA",
+  flow: "FLOW",
+  rootstock: "RBTC",
+  zetachain: "ZETA",
+  sui: "SUI"
+};
+function isSolanaNetwork(networkId) {
+  return networkId.startsWith("solana-");
+}
+function nativeTokenSymbol(networkId) {
+  const prefix = networkId.replace(/-(mainnet|testnet|sepolia|holesky|hoodi|devnet|amoy|fuji|cardona|saigon|chiado|signet|mocha|blaze|curtis|bepolia).*$/, "");
+  return NATIVE_TOKEN_SYMBOLS[prefix] ?? "ETH";
+}
+
+// src/lib/wallet-session.ts
+import { generateKeyPairSync, randomUUID } from "crypto";
+import { readFileSync, writeFileSync, mkdirSync, rmSync, existsSync } from "fs";
+import { join, dirname } from "path";
+import { z } from "zod";
+var SESSION_FILE = "wallet-session.json";
+var SESSION_TTL_DAYS = 7;
+var SESSION_ENVELOPE_VERSION = "v1";
+var walletSessionCapabilitiesSchema = z.object({
+  "evm.signMessage": z.boolean().optional(),
+  "evm.signTypedData": z.boolean().optional(),
+  "evm.signAuthorization": z.boolean().optional(),
+  "solana.signTransaction": z.boolean().optional()
+}).strict();
+var walletSessionEnvironmentSchema = z.object({
+  platform: z.string().min(1),
+  arch: z.string().min(1),
+  nodeVersion: z.string().min(1),
+  interactive: z.boolean()
+}).strict();
+var walletSessionSchema = z.object({
+  sessionId: z.string().uuid(),
+  status: z.enum(["pending", "approved", "revoked", "expired"]),
+  createdAt: z.string().datetime(),
+  expiresAt: z.string().datetime(),
+  envelopeVersion: z.string().min(1),
+  publicKeyJwk: z.object({}).passthrough(),
+  privateKeyPem: z.string().min(1),
+  privyAppId: z.string().min(1).optional(),
+  walletId: z.string().min(1).optional(),
+  evmWalletId: z.string().min(1).optional(),
+  evmAddress: z.string().min(1).optional(),
+  solanaWalletId: z.string().min(1).optional(),
+  solanaAddress: z.string().min(1).optional(),
+  privyKeyQuorumId: z.string().min(1).optional(),
+  privySignerId: z.string().min(1).optional(),
+  chainType: z.string().min(1).optional(),
+  backendBaseUrl: z.string().min(1).optional(),
+  environment: walletSessionEnvironmentSchema.optional(),
+  capabilities: walletSessionCapabilitiesSchema.optional()
+}).strict();
+function sessionPath() {
+  return join(configDir(), SESSION_FILE);
+}
+function parseStoredSession(value) {
+  const parsed = walletSessionSchema.safeParse(value);
+  if (!parsed.success) return null;
+  return parsed.data;
+}
+function loadStoredSessionFromPath(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return parseStoredSession(JSON.parse(readFileSync(path, "utf-8")));
+  } catch {
+    return null;
+  }
+}
+function isExpired(session) {
+  const expiresAt = new Date(session.expiresAt);
+  return !Number.isNaN(expiresAt.getTime()) && expiresAt <= /* @__PURE__ */ new Date();
+}
+function createFileWalletSessionStore(path = sessionPath()) {
+  return {
+    load() {
+      const session = loadStoredSessionFromPath(path);
+      if (!session) return null;
+      if (session.status === "revoked") return null;
+      if (isExpired(session)) return null;
+      return session;
+    },
+    loadRaw() {
+      return loadStoredSessionFromPath(path);
+    },
+    save(session) {
+      mkdirSync(dirname(path), { recursive: true, mode: 493 });
+      writeFileSync(path, JSON.stringify(session, null, 2) + "\n", { mode: 384 });
+    },
+    clear() {
+      if (!existsSync(path)) return false;
+      try {
+        rmSync(path, { force: true });
+        return true;
+      } catch {
+        return false;
+      }
+    }
+  };
+}
+var walletSessionStore = null;
+function getWalletSessionStore() {
+  if (!walletSessionStore) {
+    walletSessionStore = createFileWalletSessionStore();
+  }
+  return walletSessionStore;
+}
+function generateP256Keypair() {
+  const { publicKey, privateKey } = generateKeyPairSync("ec", {
+    namedCurve: "P-256"
+  });
+  const publicKeyJwk = publicKey.export({ format: "jwk" });
+  const privateKeyPem = privateKey.export({
+    type: "pkcs8",
+    format: "pem"
+  });
+  return { publicKeyJwk, privateKeyPem };
+}
+function createPendingSession() {
+  const keypair = generateP256Keypair();
+  const now = /* @__PURE__ */ new Date();
+  const expiresAt = new Date(now.getTime() + SESSION_TTL_DAYS * 24 * 60 * 60 * 1e3);
+  const session = {
+    sessionId: randomUUID(),
+    status: "pending",
+    createdAt: now.toISOString(),
+    expiresAt: expiresAt.toISOString(),
+    envelopeVersion: SESSION_ENVELOPE_VERSION,
+    publicKeyJwk: keypair.publicKeyJwk,
+    privateKeyPem: keypair.privateKeyPem
+  };
+  saveSession(session);
+  return session;
+}
+function loadSession() {
+  return getWalletSessionStore().load();
+}
+function loadStoredSession() {
+  const store = getWalletSessionStore();
+  if (store.loadRaw) {
+    return store.loadRaw();
+  }
+  return store.load();
+}
+function saveSession(session) {
+  getWalletSessionStore().save(session);
+}
+function updateSession(updates) {
+  const session = loadSession();
+  if (!session) return null;
+  const updated = { ...session, ...updates };
+  saveSession(updated);
+  return updated;
+}
+function clearSession() {
+  return getWalletSessionStore().clear();
+}
+function isSessionValid(session) {
+  if (session.status !== "approved") return false;
+  const expiresAt = new Date(session.expiresAt);
+  if (Number.isNaN(expiresAt.getTime())) return false;
+  return expiresAt > /* @__PURE__ */ new Date();
+}
+
 // src/lib/resolve.ts
+function getCommandOptions(program) {
+  const commandWithGlobals = program;
+  return commandWithGlobals.optsWithGlobals?.() ?? program.opts();
+}
 function resolveAPIKey(program, cfg) {
-  const opts = program.opts();
+  const opts = getCommandOptions(program);
   if (opts.apiKey) return opts.apiKey;
   if (process.env.ALCHEMY_API_KEY) return process.env.ALCHEMY_API_KEY;
   const config = cfg ?? load();
@@ -602,40 +1023,52 @@ function resolveAPIKey(program, cfg) {
   if (config.app?.apiKey) return config.app.apiKey;
   return void 0;
 }
-function resolveAccessKey(program, cfg) {
-  const opts = program.opts();
-  if (opts.accessKey) return opts.accessKey;
+function resolveAccessKey(_program, cfg) {
   if (process.env.ALCHEMY_ACCESS_KEY) return process.env.ALCHEMY_ACCESS_KEY;
   const config = cfg ?? load();
   if (config.access_key) return config.access_key;
   return void 0;
 }
 function resolveNetwork(program, cfg, defaultNetwork) {
-  const opts = program.opts();
+  const opts = getCommandOptions(program);
   if (opts.network) return opts.network;
   if (process.env.ALCHEMY_NETWORK) return process.env.ALCHEMY_NETWORK;
   const config = cfg ?? load();
   if (config.network) return config.network;
   return defaultNetwork ?? "eth-mainnet";
 }
+function resolveSolanaNetwork(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.network) {
+    if (!isSolanaNetwork(opts.network)) {
+      throw errInvalidArgs(
+        `Network '${opts.network}' is not a Solana network. Use a solana-* network with the solana namespace.`
+      );
+    }
+    return opts.network;
+  }
+  if (process.env.ALCHEMY_NETWORK) {
+    if (!isSolanaNetwork(process.env.ALCHEMY_NETWORK)) {
+      throw errInvalidArgs(
+        `ALCHEMY_NETWORK='${process.env.ALCHEMY_NETWORK}' is not a Solana network. Use a solana-* network with the solana namespace.`
+      );
+    }
+    return process.env.ALCHEMY_NETWORK;
+  }
+  const config = cfg ?? load();
+  if (config.network && isSolanaNetwork(config.network)) {
+    return config.network;
+  }
+  return "solana-mainnet";
+}
 function resolveAppId(program, cfg) {
-  const opts = program.opts();
+  const opts = getCommandOptions(program);
   if (opts.appId) return opts.appId;
   const config = cfg ?? load();
   if (config.app?.id) return config.app.id;
   return void 0;
 }
-async function resolveAuthToken(cfg) {
-  const creds = await getCredentials();
-  if (creds?.auth_token?.trim()) {
-    if (creds.auth_token_expires_at) {
-      const expiry = new Date(creds.auth_token_expires_at);
-      if (!Number.isNaN(expiry.getTime()) && expiry <= /* @__PURE__ */ new Date()) {
-        return void 0;
-      }
-    }
-    return creds.auth_token;
-  }
+function resolveAuthToken(cfg) {
   const config = cfg ?? load();
   if (!config.auth_token?.trim()) return void 0;
   if (config.auth_token_expires_at) {
@@ -646,16 +1079,16 @@ async function resolveAuthToken(cfg) {
   }
   return config.auth_token;
 }
-async function adminClientFromFlags(program) {
+function adminClientFromFlags(program) {
   const cfg = load();
   const accessKey = resolveAccessKey(program, cfg);
   if (accessKey) return new AdminClient(accessKey);
-  const authToken = await resolveAuthToken(cfg);
+  const authToken = resolveAuthToken(cfg);
   if (authToken) return new AdminClient({ type: "auth_token", token: authToken });
   throw errAccessKeyRequired();
 }
 function resolveX402(program, cfg) {
-  const opts = program.opts();
+  const opts = getCommandOptions(program);
   if (opts.x402) return true;
   const config = cfg ?? load();
   return config.x402 === true;
@@ -668,29 +1101,97 @@ function resolveX402Client(program) {
   return new X402Client(walletKey, resolveNetwork(program, cfg));
 }
 function resolveWalletKey(program, cfg) {
-  const opts = program.opts();
+  const opts = getCommandOptions(program);
   if (opts.walletKeyFile) {
-    return readFileSync(opts.walletKeyFile, "utf-8").trim();
+    return readFileSync2(opts.walletKeyFile, "utf-8").trim();
   }
   if (process.env.ALCHEMY_WALLET_KEY) {
     return process.env.ALCHEMY_WALLET_KEY;
   }
   const config = cfg ?? load();
   if (config.wallet_key_file) {
-    return readFileSync(config.wallet_key_file, "utf-8").trim();
+    return readFileSync2(config.wallet_key_file, "utf-8").trim();
+  }
+  return void 0;
+}
+function resolveSolanaWalletKey(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.solanaWalletKeyFile) {
+    return readFileSync2(opts.solanaWalletKeyFile, "utf-8").trim();
+  }
+  if (process.env.ALCHEMY_SOLANA_WALLET_KEY) {
+    return process.env.ALCHEMY_SOLANA_WALLET_KEY;
+  }
+  const config = cfg ?? load();
+  if (config.solana_wallet_key_file) {
+    return readFileSync2(config.solana_wallet_key_file, "utf-8").trim();
+  }
+  return void 0;
+}
+function resolveGasSponsored(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.gasSponsored) return true;
+  if (process.env.ALCHEMY_EVM_GAS_SPONSORED) {
+    return process.env.ALCHEMY_EVM_GAS_SPONSORED.trim().toLowerCase() === "true";
+  }
+  const config = cfg ?? load();
+  return config.evm_gas_sponsored === true;
+}
+function resolveGasPolicyId(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.gasPolicyId) return opts.gasPolicyId;
+  if (process.env.ALCHEMY_EVM_GAS_POLICY_ID) return process.env.ALCHEMY_EVM_GAS_POLICY_ID;
+  const config = cfg ?? load();
+  return config.evm_gas_policy_id;
+}
+function resolveSolanaFeeSponsored(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.feeSponsored) return true;
+  if (process.env.ALCHEMY_SOLANA_FEE_SPONSORED) {
+    return process.env.ALCHEMY_SOLANA_FEE_SPONSORED.trim().toLowerCase() === "true";
   }
+  const config = cfg ?? load();
+  return config.solana_fee_sponsored === true;
+}
+function resolveSolanaFeePolicyId(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.feePolicyId) return opts.feePolicyId;
+  if (process.env.ALCHEMY_SOLANA_FEE_POLICY_ID) return process.env.ALCHEMY_SOLANA_FEE_POLICY_ID;
+  const config = cfg ?? load();
+  return config.solana_fee_policy_id;
+}
+function parseBoolean(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "true" || normalized === "1") return true;
+  if (normalized === "false" || normalized === "0") return false;
   return void 0;
 }
+function resolveActiveSigner(program, cfg) {
+  const opts = getCommandOptions(program);
+  if (opts.signer === "session" || opts.signer === "local") {
+    return opts.signer;
+  }
+  const env = process.env.ALCHEMY_ACTIVE_SIGNER;
+  if (env === "session" || env === "local") {
+    return env;
+  }
+  const config = cfg ?? load();
+  if (config.active_signer === "session" || config.active_signer === "local") {
+    return config.active_signer;
+  }
+  if (process.env.ALCHEMY_DELEGATED_WALLET !== void 0) {
+    const parsed = parseBoolean(process.env.ALCHEMY_DELEGATED_WALLET);
+    if (parsed === true) return "session";
+  }
+  return void 0;
+}
+function resolveDelegatedMode(program, cfg) {
+  return resolveActiveSigner(program, cfg) === "session";
+}
 function clientFromFlags(program, opts) {
   const cfg = load();
-  const network = resolveNetwork(program, cfg, opts?.defaultNetwork);
+  const network = opts?.forceNetwork ?? resolveNetwork(program, cfg, opts?.defaultNetwork);
   debug(`using network=${network}`);
-  const programOpts = program.opts();
-  if (programOpts.accessKey) {
-    throw errInvalidArgs(
-      "--access-key is for admin commands (apps, chains, webhooks). Use --api-key for RPC commands."
-    );
-  }
   if (resolveX402(program, cfg)) {
     const walletKey = resolveWalletKey(program, cfg);
     if (!walletKey) throw errWalletKeyRequired();
@@ -715,23 +1216,51 @@ function appNetworkToSlug(rpcUrl) {
 async function resolveConfiguredNetworkSlugs(program, appIdOverride) {
   const appId = appIdOverride || resolveAppId(program);
   if (!appId) throw errAppRequired();
-  const admin = await adminClientFromFlags(program);
+  const admin = adminClientFromFlags(program);
   const app = await admin.getApp(appId);
   const slugs = app.chainNetworks.map((network) => appNetworkToSlug(network.rpcUrl)).filter((slug) => Boolean(slug));
   return Array.from(new Set(slugs)).sort((a, b) => a.localeCompare(b));
 }
+function resolveWalletSession() {
+  const session = loadSession();
+  if (!session) return null;
+  if (!isSessionValid(session)) return null;
+  return session;
+}
+var resolveDelegatedSession = resolveWalletSession;
 
 export {
   AdminClient,
+  getRPCNetworks,
+  getRPCNetworkIds,
+  isSolanaNetwork,
+  nativeTokenSymbol,
+  createPendingSession,
+  loadSession,
+  loadStoredSession,
+  saveSession,
+  updateSession,
+  clearSession,
+  isSessionValid,
   resolveAPIKey,
   resolveAccessKey,
   resolveNetwork,
+  resolveSolanaNetwork,
   resolveAppId,
   resolveAuthToken,
   adminClientFromFlags,
   resolveX402,
   resolveX402Client,
   resolveWalletKey,
+  resolveSolanaWalletKey,
+  resolveGasSponsored,
+  resolveGasPolicyId,
+  resolveSolanaFeeSponsored,
+  resolveSolanaFeePolicyId,
+  resolveActiveSigner,
+  resolveDelegatedMode,
   clientFromFlags,
-  resolveConfiguredNetworkSlugs
+  resolveConfiguredNetworkSlugs,
+  resolveWalletSession,
+  resolveDelegatedSession
 };