@alchemy/wallet-apis 5.0.0-beta.3 → 5.0.0-beta.31

package/src/adapters/fromWalletAdapter.ts

@@ -0,0 +1,58 @@
+import type { SolanaSigner } from "../types.js";
+import type { VersionedTransaction } from "@solana/web3.js";
+import { SolanaSignerError } from "./SolanaSignerError.js";
+
+/** Any signer with a `publicKey` and `signTransaction(VersionedTransaction)` method — matches `useWallet()` from `@solana/wallet-adapter-react` and injected wallet providers like `window.phantom.solana`. */
+export interface WalletAdapterSigner {
+  publicKey: { toBase58(): string };
+  signTransaction: <T extends VersionedTransaction>(
+    transaction: T,
+  ) => Promise<T>;
+}
+
+/**
+ * Adapts a wallet that signs `VersionedTransaction` objects into a {@link SolanaSigner}.
+ *
+ * Works with `useWallet()` from `@solana/wallet-adapter-react` and injected
+ * browser wallet providers (e.g. `window.phantom.solana`). Handles the
+ * `Uint8Array` ↔ `VersionedTransaction` conversion internally.
+ *
+ * For `@solana/kit` signers, use {@link fromKitSigner}. For raw Ed25519
+ * keypairs, use {@link fromKeypair}. For wallet-standard wallets, use
+ * {@link fromWalletStandard}.
+ *
+ * Requires `@solana/web3.js` as a peer dependency.
+ *
+ * @param {WalletAdapterSigner} signer - The wallet adapter signer
+ * @returns {SolanaSigner} A SolanaSigner compatible with `createSmartWalletClient`
+ */
+export function fromWalletAdapter(signer: WalletAdapterSigner): SolanaSigner {
+  return {
+    address: signer.publicKey.toBase58(),
+    async signTransaction({ transaction }) {
+      let tx: VersionedTransaction;
+      try {
+        const web3 = await import("@solana/web3.js");
+        tx = web3.VersionedTransaction.deserialize(transaction);
+      } catch (e) {
+        throw new SolanaSignerError("Failed to deserialize transaction", {
+          cause: e as Error,
+        });
+      }
+
+      let signed: VersionedTransaction;
+      try {
+        signed = await signer.signTransaction(tx);
+      } catch (e) {
+        throw new SolanaSignerError(
+          "Wallet adapter failed to sign transaction",
+          {
+            cause: e as Error,
+          },
+        );
+      }
+
+      return { signedTransaction: new Uint8Array(signed.serialize()) };
+    },
+  };
+}

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

@@ -49,6 +49,11 @@ import {
   type GetCapabilitiesParams,
   type GetCapabilitiesResult,
 } from "../actions/getCapabilities.js";
+import {
+  undelegateAccount,
+  type UndelegateAccountParams,
+  type UndelegateAccountResult,
+} from "../actions/undelegateAccount.js";
 import type { InnerWalletApiClient } from "../types.js";
 import {
   getCallsStatus,
@@ -89,6 +94,9 @@ export type SmartWalletActions = {
   getCapabilities: (
     params?: GetCapabilitiesParams | undefined,
   ) => Promise<GetCapabilitiesResult>;
+  undelegateAccount: (
+    params?: UndelegateAccountParams,
+  ) => Promise<UndelegateAccountResult>;
 };
 
 /**
@@ -101,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),
@@ -113,7 +121,8 @@ export const smartWalletActions = (
   signTypedData: (params) => signTypedData(client, params),
   grantPermissions: (params) => grantPermissions(client, params),
   getCapabilities: (params) => getCapabilities(client, params),
-  // Viem methods.
+  undelegateAccount: (params) => undelegateAccount(client, params),
+  // 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,21 +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>;
 
-export type RequestQuoteV0Params = Prettify<
-  WithCapabilities<
-    DistributiveOmit<BaseRequestQuoteV0Params, "from" | "chainId"> & {
-      account?: AccountParam;
-      chainId?: number;
+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<
+  {
+    fromToken: Address;
+    toToken: Address;
+    slippage?: bigint;
+    account?: AccountParam;
+    chainId?: number;
+  } & SwapAmountParams &
+    SwapChainParams &
+    SwapExecutionParams
 >;
 
 /** The modifiedRequest in client format: `account` instead of `from`, SDK capabilities. */
@@ -44,6 +62,9 @@ type ClientModifiedRequest = Prettify<
   }
 >;
 
+/**
+ * Result returned by the experimental `requestQuoteV0` action.
+ */
 export type RequestQuoteV0Result =
   | Exclude<RequestQuoteV0Response, { type: "paymaster-permit" }>
   | (Omit<
@@ -61,13 +82,15 @@ export type RequestQuoteV0Result =
  * @param {RequestQuoteV0Params} params - Parameters for requesting a swap quote
  * @param {Address} params.fromToken - The address of the token to swap from
  * @param {Address} params.toToken - The address of the token to swap to
- * @param {Hex} [params.fromAmount] - The amount to swap from (mutually exclusive with minimumToAmount)
- * @param {Hex} [params.minimumToAmount] - The minimum amount to receive (mutually exclusive with fromAmount)
+ * @param {bigint} [params.fromAmount] - The amount to swap from (mutually exclusive with minimumToAmount)
+ * @param {bigint} [params.minimumToAmount] - The minimum amount to receive (mutually exclusive with fromAmount)
  * @param {AccountParam} [params.account] - The account to execute the swap from. Can be an address string or an object with an `address` property. Defaults to the client's account (signer address via EIP-7702).
- * @param {Hex} [params.slippage] - The maximum acceptable slippage percentage
+ * @param {number} [params.chainId] - The source chain ID. Defaults to the wallet client's chain.
+ * @param {number} [params.toChainId] - The destination chain ID for cross-chain swaps. Omit for same-chain swaps.
+ * @param {bigint} [params.slippage] - The maximum acceptable slippage in basis points.
  * @param {boolean} [params.returnRawCalls] - Whether to return raw calls for EOA wallets (defaults to false for smart wallets)
  * @param {object} [params.capabilities] - Optional capabilities to include with the request (only available when returnRawCalls is false)
- * @param {Array<{to: Address, data?: Hex, value?: Hex}>} [params.postCalls] - Optional calls to execute after the swap
+ * @param {Array<{ to: Address; data?: Hex; value?: bigint }>} [params.postCalls] - Optional calls to execute after the swap
  * @returns {Promise<RequestQuoteV0Result>} A Promise that resolves to either prepared calls or raw calls depending on returnRawCalls
  *
  * @example
@@ -77,6 +100,7 @@ export type RequestQuoteV0Result =
  *   fromToken: "0xA0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
  *   toToken: "0xB0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
  *   fromAmount: 1000000000000000000n, // 1 ETH
+ *   chainId: 42161, // Arbitrum
  *   capabilities: {
  *     paymaster: { policyId: "your-policy-id" }
  *   }
@@ -87,6 +111,7 @@ export type RequestQuoteV0Result =
  *   fromToken: "0xA0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
  *   toToken: "0xB0b86a33E6441e1d6a8E8C7a8E8E8E8E8E8E8E8E",
  *   fromAmount: 1000000000000000000n,
+ *   chainId: 42161,
  *   returnRawCalls: true
  * });
  * ```

package/src/experimental/swapActionsDecorator.ts

@@ -5,6 +5,9 @@ import {
 } from "./actions/requestQuoteV0.js";
 import type { BaseWalletClient, InnerWalletApiClient } from "../types.js";
 
+/**
+ * Experimental swap actions for wallet API clients.
+ */
 export type SwapActions = {
   requestQuoteV0: (
     params: RequestQuoteV0Params,

package/src/exports/index.ts

@@ -25,18 +25,24 @@ export type * from "../actions/signSignatureRequest.js";
 export { signSignatureRequest } from "../actions/signSignatureRequest.js";
 export type * from "../actions/signTypedData.js";
 export { signTypedData } from "../actions/signTypedData.js";
+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";