@alchemy/wallet-apis 5.0.0-beta.27 → 5.0.0-beta.29

package/src/adapters/fromWalletStandard.ts

@@ -0,0 +1,100 @@
+import { SolanaSignerError } from "./SolanaSignerError.js";
+import type { SolanaSigner } from "../types.js";
+
+const SIGN_TRANSACTION = "solana:signTransaction";
+
+/** Minimal structural shape of a wallet-standard account. */
+export interface WalletStandardAccount {
+  address: string;
+  publicKey?: Uint8Array;
+  chains?: readonly string[];
+  features?: readonly string[];
+  [key: string]: unknown;
+}
+
+/** Minimal structural shape of a wallet-standard wallet. */
+export interface WalletStandardWallet {
+  features: { readonly [name: string]: unknown };
+}
+
+interface SolanaSignTransactionFeature {
+  readonly signTransaction: (
+    ...inputs: readonly {
+      account: WalletStandardAccount;
+      transaction: Uint8Array;
+    }[]
+  ) => Promise<readonly { signedTransaction: Uint8Array }[]>;
+}
+
+function isSolanaSignTransactionFeature(
+  feature: unknown,
+): feature is SolanaSignTransactionFeature {
+  return (
+    typeof feature === "object" &&
+    feature !== null &&
+    "signTransaction" in feature &&
+    typeof (feature as { signTransaction?: unknown }).signTransaction ===
+      "function"
+  );
+}
+
+/**
+ * Adapts a Wallet Standard wallet into a {@link SolanaSigner}.
+ *
+ * Works with any wallet that implements the `solana:signTransaction` feature
+ * from the Wallet Standard spec (Phantom, Solflare, etc.). No peer dependency
+ * required — the interface uses `Uint8Array` directly.
+ *
+ * For `@solana/wallet-adapter-react` wallets, use {@link fromWalletAdapter}.
+ * For `@solana/kit` signers, use {@link fromKitSigner}. For raw Ed25519
+ * keypairs, use {@link fromKeypair}.
+ *
+ * @param {WalletStandardWallet} wallet - The wallet-standard wallet object
+ * @param {WalletStandardAccount} account - The account to sign with
+ * @returns {SolanaSigner} A SolanaSigner compatible with `createSmartWalletClient`
+ */
+export function fromWalletStandard(
+  wallet: WalletStandardWallet,
+  account: WalletStandardAccount,
+): SolanaSigner {
+  const feature = wallet.features[SIGN_TRANSACTION];
+
+  if (!isSolanaSignTransactionFeature(feature)) {
+    throw new SolanaSignerError(
+      `Wallet does not support the "${SIGN_TRANSACTION}" feature.`,
+    );
+  }
+
+  if (account.features && !account.features.includes(SIGN_TRANSACTION)) {
+    throw new SolanaSignerError(
+      `Account ${account.address} does not support the "${SIGN_TRANSACTION}" feature.`,
+    );
+  }
+
+  return {
+    address: account.address,
+    async signTransaction({ transaction }) {
+      let output: { signedTransaction: Uint8Array } | undefined;
+      try {
+        [output] = await feature.signTransaction({ account, transaction });
+      } catch (e) {
+        throw new SolanaSignerError(
+          "Wallet standard wallet failed to sign transaction",
+          { cause: e as Error },
+        );
+      }
+
+      if (!output) {
+        throw new SolanaSignerError("Wallet returned no signed transaction.");
+      }
+
+      if (!(output.signedTransaction instanceof Uint8Array)) {
+        throw new SolanaSignerError(
+          "Wallet returned an invalid signed transaction.",
+        );
+      }
+
+      return output;
+    },
+  };
+}

package/src/adapters/resolveSignerSlot.ts

@@ -0,0 +1,46 @@
+import { SolanaSignerError } from "./SolanaSignerError.js";
+
+/**
+ * Finds the signature slot index for `signerAddress` by decoding the
+ * transaction message and looking up the address in the account keys.
+ * Tries `@solana/kit` first, falls back to `@solana/web3.js`.
+ *
+ * @param {Uint8Array} transaction - The serialized Solana transaction bytes
+ * @param {string} signerAddress - The base58-encoded address of the signer
+ * @returns {Promise<number>} The slot index, or -1 if the address is not a required signer
+ */
+export async function findSignerSlot(
+  transaction: Uint8Array,
+  signerAddress: string,
+): Promise<number> {
+  let accounts: readonly string[];
+  let numRequiredSigners: number;
+
+  try {
+    const { getCompiledTransactionMessageDecoder } = await import(
+      "@solana/kit"
+    );
+    const numSigs = transaction[0];
+    const messageBytes = transaction.slice(1 + numSigs * 64);
+    const decoded = getCompiledTransactionMessageDecoder().decode(messageBytes);
+    accounts = decoded.staticAccounts as readonly string[];
+    numRequiredSigners = decoded.header.numSignerAccounts;
+  } catch {
+    try {
+      const { VersionedTransaction } = await import("@solana/web3.js");
+      const vtx = VersionedTransaction.deserialize(transaction);
+      accounts = vtx.message.staticAccountKeys.map((k) => k.toBase58());
+      numRequiredSigners = vtx.message.header.numRequiredSignatures;
+    } catch {
+      throw new SolanaSignerError(
+        "Failed to decode transaction: install @solana/kit or @solana/web3.js",
+      );
+    }
+  }
+
+  const slotIndex = accounts.indexOf(signerAddress);
+  if (slotIndex < 0 || slotIndex >= numRequiredSigners) {
+    return -1;
+  }
+  return slotIndex;
+}

package/src/client.ts

@@ -1,11 +1,51 @@
-import { createClient, type Address, type Chain } from "viem";
+import { BaseError } from "@alchemy/common";
+import { createClient, defineChain, type Address, type Chain } from "viem";
 import { smartWalletActions } from "./decorators/smartWalletActions.js";
-import type { SmartWalletClient, SmartWalletSigner } from "./types.js";
+import { solanaSmartWalletActions } from "./decorators/solanaSmartWalletActions.js";
+import type {
+  SmartWalletClient,
+  SmartWalletSigner,
+  SolanaSmartWalletClient,
+  SolanaSigner,
+  SolanaChainDef,
+} from "./types.js";
 import { createInternalState } from "./internal.js";
 import { isLocalAccount } from "./utils/assertions.js";
 import type { AlchemyWalletTransport } from "./transport.js";
+import type { SolanaChainId } from "@alchemy/wallet-api-types";
 
-export type CreateSmartWalletClientParams = {
+// ── Solana chain definitions ────────────────────────────────────────────
+
+const solanaMainnet: SolanaChainDef = {
+  ...defineChain({
+    id: 0,
+    name: "Solana Mainnet",
+    nativeCurrency: { name: "SOL", symbol: "SOL", decimals: 9 },
+    rpcUrls: { default: { http: [] } },
+  }),
+  solanaChainId: "solana:mainnet",
+};
+
+const solanaDevnet: SolanaChainDef = {
+  ...defineChain({
+    id: 0,
+    name: "Solana Devnet",
+    nativeCurrency: { name: "SOL", symbol: "SOL", decimals: 9 },
+    rpcUrls: { default: { http: [] } },
+  }),
+  solanaChainId: "solana:devnet",
+};
+
+export const SOLANA_CHAINS: Record<SolanaChainId, SolanaChainDef> = {
+  "solana:mainnet": solanaMainnet,
+  "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp": solanaMainnet,
+  "solana:devnet": solanaDevnet,
+  "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": solanaDevnet,
+};
+
+// ── Param types ─────────────────────────────────────────────────────────
+
+export type CreateEvmSmartWalletClientParams = {
   signer: SmartWalletSigner;
   transport: AlchemyWalletTransport;
   chain: Chain;
@@ -16,30 +56,71 @@ export type CreateSmartWalletClientParams = {
   };
 };
 
+export type CreateSolanaSmartWalletClientParams = {
+  signer: SolanaSigner;
+  transport: AlchemyWalletTransport;
+  chain: SolanaChainId;
+  account?: string;
+  paymaster?: {
+    policyId: string;
+  };
+};
+
+/** Either {@link CreateEvmSmartWalletClientParams} or {@link CreateSolanaSmartWalletClientParams}. */
+export type CreateSmartWalletClientParams =
+  | CreateEvmSmartWalletClientParams
+  | CreateSolanaSmartWalletClientParams;
+
+// ── Factory ─────────────────────────────────────────────────────────────
+
+function isSolanaParams(
+  params: CreateSmartWalletClientParams,
+): params is CreateSolanaSmartWalletClientParams {
+  return typeof params.chain === "string" && params.chain.startsWith("solana:");
+}
+
 /**
- * Creates a smart wallet client with wallet API actions.
+ * Creates a smart wallet client for EVM chains with actions for preparing,
+ * signing, and sending user operations.
  *
- * By default, the client uses EIP-7702 with the signer's address, allowing you to call
- * `prepareCalls` or `sendCalls` directly without first calling `requestAccount`.
- * Use `requestAccount` only if you need a non-7702 smart account.
+ * @param {CreateEvmSmartWalletClientParams} params - EVM client configuration
+ * @returns {SmartWalletClient} An EVM smart wallet client with smart wallet actions
+ */
+export function createSmartWalletClient(
+  params: CreateEvmSmartWalletClientParams,
+): SmartWalletClient;
+/**
+ * Creates a smart wallet client for Solana chains with actions for preparing,
+ * signing, and sending transactions.
  *
- * @param {CreateSmartWalletClientParams} params - Parameters for creating the smart wallet client.
- * @param {SmartWalletSigner} params.signer - The signer to use for signing transactions.
- * @param {AlchemyWalletTransport} params.transport - The transport to use for RPC calls.
- * @param {Chain} params.chain - The blockchain network to connect to.
- * @param {AccountParam} [params.account] - Optional account. Can be an address string or an object with an `address` property. Defaults to the signer's address (EIP-7702).
- * @param {object} [params.paymaster] - Optional paymaster configuration with policy IDs.
- * @returns {SmartWalletClient} A wallet client extended with smart wallet actions.
+ * Solana-specific adapters are in `@alchemy/wallet-apis/solana`.
+ *
+ * @param {CreateSolanaSmartWalletClientParams} params - Solana client configuration
+ * @returns {SolanaSmartWalletClient} A Solana smart wallet client with Solana smart wallet actions
  */
-export const createSmartWalletClient = ({
+export function createSmartWalletClient(
+  params: CreateSolanaSmartWalletClientParams,
+): SolanaSmartWalletClient;
+export function createSmartWalletClient(
+  params: CreateSmartWalletClientParams,
+): SmartWalletClient | SolanaSmartWalletClient {
+  if (isSolanaParams(params)) {
+    return createSolanaClient(params);
+  }
+  return createEvmClient(params);
+}
+
+// ── EVM path ────────────────────────────────────────────────────────────
+
+function createEvmClient({
   signer,
   transport,
   chain,
   account,
   paymaster,
-}: CreateSmartWalletClientParams): SmartWalletClient => {
+}: CreateEvmSmartWalletClientParams): SmartWalletClient {
   const _policyIds = [
-    ...(paymaster?.policyId ? [paymaster?.policyId] : []),
+    ...(paymaster?.policyId ? [paymaster.policyId] : []),
     ...(paymaster?.policyIds ?? []),
   ];
 
@@ -60,4 +141,36 @@ export const createSmartWalletClient = ({
       owner: signer,
     }))
     .extend(smartWalletActions);
-};
+}
+
+// ── Solana path ─────────────────────────────────────────────────────────
+
+function createSolanaClient({
+  signer,
+  transport,
+  chain,
+  account,
+  paymaster,
+}: CreateSolanaSmartWalletClientParams): SolanaSmartWalletClient {
+  const _policyIds = paymaster?.policyId ? [paymaster.policyId] : [];
+
+  const _account = account ?? signer.address;
+
+  const _chain = SOLANA_CHAINS[chain];
+  if (!_chain) {
+    throw new BaseError(`Unsupported Solana chain: ${chain}`);
+  }
+
+  return createClient({
+    transport,
+    chain: _chain,
+    name: "alchemySolanaSmartWalletClient",
+  })
+    .extend(() => ({
+      policyIds: _policyIds,
+      internal: createInternalState(),
+      owner: signer,
+      solanaAccount: _account,
+    }))
+    .extend(solanaSmartWalletActions);
+}

package/src/decorators/smartWalletActions.ts

@@ -109,7 +109,7 @@ export type SmartWalletActions = {
 export const smartWalletActions = (
   client: InnerWalletApiClient,
 ): SmartWalletActions => ({
-  // Alchemy methods.
+  // Alchemy actions.
   requestAccount: (params) => requestAccount(client, params),
   prepareCalls: (params) => prepareCalls(client, params),
   listAccounts: (params) => listAccounts(client, params),
@@ -122,7 +122,7 @@ export const smartWalletActions = (
   grantPermissions: (params) => grantPermissions(client, params),
   getCapabilities: (params) => getCapabilities(client, params),
   undelegateAccount: (params) => undelegateAccount(client, params),
-  // Viem methods.
+  // Viem actions.
   getCallsStatus: (params) => getCallsStatus(client, params),
   waitForCallsStatus: (params) => waitForCallsStatus(client, params),
 });

package/src/decorators/solanaSmartWalletActions.ts

@@ -0,0 +1,62 @@
+import type { InnerSolanaWalletApiClient } from "../types.js";
+import {
+  prepareCalls,
+  type SolanaPrepareCallsParams,
+  type SolanaPrepareCallsResult,
+} from "../actions/solana/prepareCalls.js";
+import {
+  signPreparedCalls,
+  type SolanaSignPreparedCallsParams,
+  type SolanaSignPreparedCallsResult,
+} from "../actions/solana/signPreparedCalls.js";
+import {
+  sendPreparedCalls,
+  type SolanaSendPreparedCallsParams,
+  type SolanaSendPreparedCallsResult,
+} from "../actions/solana/sendPreparedCalls.js";
+import {
+  sendCalls,
+  type SolanaSendCallsParams,
+  type SolanaSendCallsResult,
+} from "../actions/solana/sendCalls.js";
+import {
+  getCallsStatus,
+  type SolanaGetCallsStatusParams,
+  type SolanaGetCallsStatusResult,
+} from "../actions/solana/getCallsStatus.js";
+import {
+  waitForCallsStatus,
+  type SolanaWaitForCallsStatusParams,
+  type SolanaWaitForCallsStatusResult,
+} from "../actions/solana/waitForCallsStatus.js";
+
+export type SolanaSmartWalletActions = {
+  prepareCalls: (
+    params: SolanaPrepareCallsParams,
+  ) => Promise<SolanaPrepareCallsResult>;
+  signPreparedCalls: (
+    params: SolanaSignPreparedCallsParams,
+  ) => Promise<SolanaSignPreparedCallsResult>;
+  sendPreparedCalls: (
+    params: SolanaSendPreparedCallsParams,
+  ) => Promise<SolanaSendPreparedCallsResult>;
+  sendCalls: (params: SolanaSendCallsParams) => Promise<SolanaSendCallsResult>;
+  getCallsStatus: (
+    params: SolanaGetCallsStatusParams,
+  ) => Promise<SolanaGetCallsStatusResult>;
+  waitForCallsStatus: (
+    params: SolanaWaitForCallsStatusParams,
+  ) => Promise<SolanaWaitForCallsStatusResult>;
+};
+
+export const solanaSmartWalletActions = (
+  client: InnerSolanaWalletApiClient,
+): SolanaSmartWalletActions => ({
+  prepareCalls: (params) => prepareCalls(client, params),
+  signPreparedCalls: (params) => signPreparedCalls(client, params),
+  sendPreparedCalls: (params) => sendPreparedCalls(client, params),
+  sendCalls: (params) => sendCalls(client, params),
+  // Note that status actions from Viem don't work since the chain ID is not hex.
+  getCallsStatus: (params) => getCallsStatus(client, params),
+  waitForCallsStatus: (params) => waitForCallsStatus(client, params),
+});

package/src/experimental/actions/requestQuoteV0.ts

@@ -1,11 +1,10 @@
-import type { Address, Prettify } from "viem";
-import type { DistributiveOmit, InnerWalletApiClient } from "../../types.ts";
+import type { Address, Hex, Prettify } from "viem";
+import type { InnerWalletApiClient } from "../../types.ts";
 import {
   fromRpcCapabilities,
   mergeClientCapabilities,
   toRpcCapabilities,
   type PrepareCallsCapabilities,
-  type WithCapabilities,
 } from "../../utils/capabilities.js";
 import { resolveAddress, type AccountParam } from "../../utils/resolve.js";
 import { wallet_requestQuote_v0 as MethodSchema } from "@alchemy/wallet-api-types/rpc";
@@ -13,24 +12,40 @@ import {
   methodSchema,
   encode,
   decode,
-  type MethodParams,
   type MethodResponse,
 } from "../../utils/schema.js";
 
 const schema = methodSchema(MethodSchema);
-type BaseRequestQuoteV0Params = MethodParams<typeof MethodSchema>;
 type RequestQuoteV0Response = MethodResponse<typeof MethodSchema>;
 
+type SwapAmountParams =
+  | { fromAmount: bigint; minimumToAmount?: never }
+  | { fromAmount?: never; minimumToAmount: bigint };
+
+type SwapChainParams =
+  | {
+      toChainId?: never;
+      postCalls?: Array<{ to: Address; data?: Hex; value?: bigint }>;
+    }
+  | { toChainId: number; postCalls?: never };
+
+type SwapExecutionParams =
+  | { returnRawCalls?: false; capabilities?: PrepareCallsCapabilities }
+  | { returnRawCalls: true; capabilities?: never };
+
 /**
  * Parameters accepted by the experimental `requestQuoteV0` action.
  */
 export type RequestQuoteV0Params = Prettify<
-  WithCapabilities<
-    DistributiveOmit<BaseRequestQuoteV0Params, "from" | "chainId"> & {
-      account?: AccountParam;
-      chainId?: number;
-    }
-  >
+  {
+    fromToken: Address;
+    toToken: Address;
+    slippage?: bigint;
+    account?: AccountParam;
+    chainId?: number;
+  } & SwapAmountParams &
+    SwapChainParams &
+    SwapExecutionParams
 >;
 
 /** The modifiedRequest in client format: `account` instead of `from`, SDK capabilities. */

package/src/exports/index.ts

@@ -29,16 +29,20 @@ export type * from "../actions/undelegateAccount.js";
 export { undelegateAccount } from "../actions/undelegateAccount.js";
 
 // Decorators.
-export type * from "../decorators/smartWalletActions.js";
+export type { SmartWalletActions } from "../decorators/smartWalletActions.js";
 export { smartWalletActions } from "../decorators/smartWalletActions.js";
 
 // Client.
 export type {
-  BaseWalletClient,
-  SignerClient,
   SmartWalletClient,
+  SolanaSmartWalletClient,
+  SolanaSigner,
 } from "../types.js";
-export type * from "../client.js";
+export type {
+  CreateEvmSmartWalletClientParams,
+  CreateSolanaSmartWalletClientParams,
+  CreateSmartWalletClientParams,
+} from "../client.js";
 export { createSmartWalletClient } from "../client.js";
 
 // Transport.

package/src/exports/solana.ts

@@ -0,0 +1,36 @@
+// Actions.
+export type * from "../actions/solana/prepareCalls.js";
+export { prepareCalls } from "../actions/solana/prepareCalls.js";
+export type * from "../actions/solana/signPreparedCalls.js";
+export { signPreparedCalls } from "../actions/solana/signPreparedCalls.js";
+export type * from "../actions/solana/sendPreparedCalls.js";
+export { sendPreparedCalls } from "../actions/solana/sendPreparedCalls.js";
+export type * from "../actions/solana/sendCalls.js";
+export { sendCalls } from "../actions/solana/sendCalls.js";
+export type * from "../actions/solana/getCallsStatus.js";
+export { getCallsStatus } from "../actions/solana/getCallsStatus.js";
+export type * from "../actions/solana/waitForCallsStatus.js";
+export { waitForCallsStatus } from "../actions/solana/waitForCallsStatus.js";
+
+// Decorator.
+export type { SolanaSmartWalletActions } from "../decorators/solanaSmartWalletActions.js";
+export { solanaSmartWalletActions } from "../decorators/solanaSmartWalletActions.js";
+
+// Errors.
+export { SolanaSignerError } from "../adapters/SolanaSignerError.js";
+
+// Adapters.
+export { fromKeypair } from "../adapters/fromKeypair.js";
+export type { SolanaKeypairSigner } from "../adapters/fromKeypair.js";
+export { fromKitSigner } from "../adapters/fromKitSigner.js";
+export type { SolanaTransactionPartialSigner } from "../adapters/fromKitSigner.js";
+export { fromWalletAdapter } from "../adapters/fromWalletAdapter.js";
+export type { WalletAdapterSigner } from "../adapters/fromWalletAdapter.js";
+export { fromWalletStandard } from "../adapters/fromWalletStandard.js";
+export type {
+  WalletStandardWallet,
+  WalletStandardAccount,
+} from "../adapters/fromWalletStandard.js";
+
+// Types.
+export type { SolanaSigner, SolanaSmartWalletClient } from "../types.js";

package/src/types.ts

@@ -1,4 +1,5 @@
 import type { WalletServerViemRpcSchema } from "@alchemy/wallet-api-types/rpc";
+import type { SolanaChainId } from "@alchemy/wallet-api-types";
 import type {
   Account,
   Address,
@@ -12,31 +13,61 @@ import type {
 } from "viem";
 import type { InternalState } from "./internal";
 import type { SmartWalletActions } from "./decorators/smartWalletActions";
+import type { SolanaSmartWalletActions } from "./decorators/solanaSmartWalletActions";
 
 export type BaseWalletClient<
   TExtend extends { [key: string]: unknown } | undefined =
     | { [key: string]: unknown }
     | undefined,
+  TAccount extends Account | undefined = JsonRpcAccount<Address>,
 > = Client<
   Transport<"alchemyHttp">,
   Chain,
-  JsonRpcAccount<Address>,
+  TAccount,
   WalletServerViemRpcSchema,
   TExtend
 >;
 
-export type InnerWalletApiClient = BaseWalletClient<{
-  internal: InternalState | undefined; // undefined if you want to skip using an internal cache
-  owner: SmartWalletSigner;
-  policyIds?: string[];
-}>;
-
 export type SignerClient = WalletClient<Transport, Chain | undefined, Account>;
 
 export type SmartWalletSigner = LocalAccount | SignerClient;
 
 export type SmartWalletClient = BaseWalletClient<SmartWalletActions>;
 
+export type SolanaSmartWalletClient = BaseWalletClient<
+  SolanaSmartWalletActions & { solanaAccount: string },
+  undefined
+>;
+
+/** Solana signer interface. Takes serialized tx bytes, returns signed serialized tx bytes. */
+export interface SolanaSigner {
+  address: string;
+  signTransaction(input: {
+    transaction: Uint8Array;
+    [key: string]: unknown;
+  }): Promise<{ signedTransaction: Uint8Array }>;
+}
+
+export interface SolanaChainDef extends Chain {
+  solanaChainId: SolanaChainId;
+}
+
+export type InnerWalletApiClient = BaseWalletClient<{
+  internal: InternalState | undefined;
+  owner: SmartWalletSigner;
+  policyIds?: string[];
+}>;
+
+export type InnerSolanaWalletApiClient = BaseWalletClient<
+  {
+    internal: InternalState | undefined;
+    owner: SolanaSigner;
+    solanaAccount: string;
+    policyIds?: string[];
+  },
+  undefined
+>;
+
 export type OptionalChainId<T> = T extends { chainId: number }
   ? Omit<T, "chainId"> & { chainId?: number | undefined }
   : T;

package/src/utils/assertions.ts

@@ -1,5 +1,10 @@
-import type { Client, LocalAccount } from "viem";
-import type { InnerWalletApiClient, SignerClient } from "../types.js";
+import type { Chain, Client, LocalAccount } from "viem";
+import type {
+  InnerWalletApiClient,
+  InnerSolanaWalletApiClient,
+  SignerClient,
+  SolanaChainDef,
+} from "../types.js";
 import { BaseError } from "@alchemy/common";
 
 /**
@@ -14,6 +19,12 @@ export function isSmartWalletClient(
   return client.name === "alchemySmartWalletClient" && "owner" in client;
 }
 
+export function isSolanaClient(
+  client: Client,
+): client is InnerSolanaWalletApiClient {
+  return client.name === "alchemySolanaSmartWalletClient" && "owner" in client;
+}
+
 /**
  * Assertion function that throws an error if the client is not an Alchemy Smart Wallet Client.
  * After this function returns successfully, TypeScript will narrow the client type.
@@ -31,6 +42,10 @@ export function assertSmartWalletClient(
   }
 }
 
+export function isSolanaChain(chain: Chain): chain is SolanaChainDef {
+  return "solanaChainId" in chain;
+}
+
 export function isLocalAccount(
   signer: LocalAccount | SignerClient,
 ): signer is LocalAccount {