@coinbase/cdp-sdk 1.15.0 → 1.16.0

package/actions/evm/swap/sendSwapOperation.ts

@@ -0,0 +1,182 @@
+import { concat, numberToHex, size } from "viem";
+
+import { createSwapQuote } from "./createSwapQuote.js";
+import { createDeterministicUuidV4 } from "../../../utils/uuidV4.js";
+import { sendUserOperation } from "../sendUserOperation.js";
+import { signAndWrapTypedDataForSmartAccount } from "../signAndWrapTypedDataForSmartAccount.js";
+
+import type { SendSwapOperationOptions, SendSwapOperationResult } from "./types.js";
+import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type {
+  CreateSwapQuoteResult,
+  CreateSwapQuoteOptions,
+  SwapUnavailableResult,
+} from "../../../client/evm/evm.types.js";
+import type {
+  CdpOpenApiClientType,
+  EvmUserOperationNetwork,
+} from "../../../openapi-client/index.js";
+import type { Hex } from "../../../types/misc.js";
+
+/**
+ * Sends a swap operation to the blockchain via a smart account user operation.
+ * Handles any permit2 signatures required for the swap.
+ *
+ * If you encounter token allowance issues, you'll need to perform a token approval transaction first to allow
+ * the Permit2 contract to spend the appropriate amount of your fromToken.
+ * See examples for code on handling token approvals.
+ *
+ * @param {CdpOpenApiClientType} client - The client to use for sending the swap operation.
+ * @param {SendSwapOperationOptions} options - The options for the swap submission.
+ *
+ * @returns {Promise<SendSwapOperationResult>} A promise that resolves to the user operation result.
+ *
+ * @throws {Error} If liquidity is not available for the swap.
+ * @throws {Error} If there are insufficient token allowances. In this case, you need to approve the
+ *                 Permit2 contract to spend your tokens before attempting the swap. The error message
+ *                 will include the current allowance and the spender address that needs approval.
+ * @throws {Error} If no transaction data is found in the swap result.
+ *
+ * @example **Sending a swap with pre-created swap quote object**
+ * ```ts
+ * // First create a swap quote
+ * const swapQuote = await cdp.evm.createSwapQuote({
+ *   network: "base",
+ *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+ *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+ *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+ *   taker: smartAccount.address
+ * });
+ *
+ * // Check if liquidity is available
+ * if (!swapQuote.liquidityAvailable) {
+ *   console.error("Insufficient liquidity for swap");
+ *   return;
+ * }
+ *
+ * // Send the swap operation
+ * const result = await sendSwapOperation(client, {
+ *   smartAccount: smartAccount,
+ *   swapQuote: swapQuote
+ * });
+ *
+ * console.log(`Swap operation sent with user op hash: ${result.userOpHash}`);
+ * ```
+ *
+ * @example **Sending a swap with inline options (all-in-one)**
+ * ```ts
+ * // Send swap operation in one call
+ * const result = await sendSwapOperation(client, {
+ *   smartAccount: smartAccount,
+ *   network: "base",
+ *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+ *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+ *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+ *   taker: smartAccount.address
+ * });
+ *
+ * console.log(`Swap operation sent with user op hash: ${result.userOpHash}`);
+ * ```
+ */
+export async function sendSwapOperation(
+  client: CdpOpenApiClientType,
+  options: SendSwapOperationOptions,
+): Promise<SendSwapOperationResult> {
+  const { smartAccount, paymasterUrl, idempotencyKey } = options;
+
+  let swapResult: CreateSwapQuoteResult | SwapUnavailableResult;
+
+  // Determine if we need to create the swap quote or use the provided one
+  if ("swapQuote" in options) {
+    // Use the provided swap quote
+    swapResult = options.swapQuote;
+  } else {
+    // Create the swap quote using the provided options (inline options)
+    /**
+     * Deterministically derive a new idempotency key from the provided idempotency key for swap quote creation to avoid key reuse.
+     */
+    const swapQuoteIdempotencyKey = idempotencyKey
+      ? createDeterministicUuidV4(idempotencyKey, "createSwapQuote")
+      : undefined;
+
+    swapResult = await createSwapQuote(client, {
+      network: options.network as CreateSwapQuoteOptions["network"],
+      toToken: options.toToken,
+      fromToken: options.fromToken,
+      fromAmount: options.fromAmount,
+      taker: options.taker,
+      signerAddress: options.signerAddress,
+      gasPrice: options.gasPrice,
+      slippageBps: options.slippageBps,
+      idempotencyKey: swapQuoteIdempotencyKey,
+    });
+  }
+
+  // Check if liquidity is available
+  if (!swapResult.liquidityAvailable) {
+    throw new Error("Insufficient liquidity for swap");
+  }
+
+  // At this point, we know that swapResult is CreateSwapQuoteResult
+  const swap = swapResult as CreateSwapQuoteResult;
+
+  // Check for allowance issues
+  if (swap.issues?.allowance) {
+    const { currentAllowance, spender } = swap.issues.allowance;
+    throw new Error(
+      `Insufficient token allowance for swap. Current allowance: ${currentAllowance}. ` +
+        `Please approve the Permit2 contract (${spender}) to spend your tokens.`,
+    );
+  }
+
+  // If the transaction doesn't exist, throw an error
+  if (!swap.transaction) {
+    throw new Error("No transaction data found in the swap");
+  }
+
+  // Get the transaction data and modify it if needed for Permit2
+  let txData = swap.transaction.data as Hex;
+
+  if (swap.permit2?.eip712) {
+    // Create the permit2 idempotency key
+    const permit2IdempotencyKey = idempotencyKey
+      ? createDeterministicUuidV4(idempotencyKey, "permit2")
+      : undefined;
+
+    // Sign and wrap the permit2 typed data according to the Coinbase Smart Wallet contract requirements for EIP-712 signatures
+    const { signature: wrappedSignature } = await signAndWrapTypedDataForSmartAccount(client, {
+      smartAccount,
+      chainId: BigInt(swap.permit2.eip712.domain.chainId || 1),
+      typedData: swap.permit2.eip712,
+      ownerIndex: 0n,
+      idempotencyKey: permit2IdempotencyKey,
+    });
+
+    // Calculate the Permit2 signature length as a 32-byte hex value
+    const permit2SignatureLengthInHex = numberToHex(size(wrappedSignature), {
+      signed: false,
+      size: 32,
+    });
+
+    // Append the Permit2 signature length and signature to the transaction data
+    txData = concat([txData, permit2SignatureLengthInHex, wrappedSignature]);
+  }
+
+  // Send the swap as a user operation
+  const result = await sendUserOperation(client, {
+    smartAccount: smartAccount as EvmSmartAccount,
+    network: swap.network as EvmUserOperationNetwork,
+    paymasterUrl,
+    idempotencyKey,
+    calls: [
+      {
+        to: swap.transaction.to,
+        data: txData,
+        // Only include value if it exists
+        ...(swap.transaction.value ? { value: BigInt(swap.transaction.value) } : {}),
+      },
+    ],
+  });
+
+  return result;
+}

package/actions/evm/swap/sendSwapTransaction.ts

@@ -1,6 +1,7 @@
 import { concat, numberToHex, size } from "viem";
 
 import { createSwapQuote } from "./createSwapQuote.js";
+import { createDeterministicUuidV4 } from "../../../utils/uuidV4.js";
 import { sendTransaction } from "../sendTransaction.js";
 
 import type { SendSwapTransactionOptions, SendSwapTransactionResult } from "./types.js";
@@ -90,6 +91,13 @@ export async function sendSwapTransaction(
     swapResult = options.swapQuote;
   } else {
     // Create the swap quote using the provided options (InlineSendSwapTransactionOptions)
+    /**
+     * Deterministically derive a new idempotency key from the provided idempotency key for swap quote creation to avoid key reuse.
+     */
+    const swapQuoteIdempotencyKey = idempotencyKey
+      ? createDeterministicUuidV4(idempotencyKey, "createSwapQuote")
+      : undefined;
+
     swapResult = await createSwapQuote(client, {
       network: options.network as CreateSwapQuoteOptions["network"],
       toToken: options.toToken,
@@ -99,6 +107,7 @@ export async function sendSwapTransaction(
       signerAddress: options.signerAddress,
       gasPrice: options.gasPrice,
       slippageBps: options.slippageBps,
+      idempotencyKey: swapQuoteIdempotencyKey,
     });
   }
 
@@ -128,7 +137,14 @@ export async function sendSwapTransaction(
   let txData = swap.transaction.data as Hex;
 
   if (swap.permit2?.eip712) {
-    // Sign the Permit2 EIP-712 message
+    /**
+     * Sign the Permit2 EIP-712 message.
+     * Deterministically derive a new idempotency key from the provided idempotency key for permit2 signing to avoid key reuse.
+     */
+    const permit2IdempotencyKey = idempotencyKey
+      ? createDeterministicUuidV4(idempotencyKey, "permit2")
+      : undefined;
+
     const signature = await client.signEvmTypedData(
       address,
       {
@@ -137,7 +153,7 @@ export async function sendSwapTransaction(
         primaryType: swap.permit2.eip712.primaryType,
         message: swap.permit2.eip712.message,
       },
-      idempotencyKey,
+      permit2IdempotencyKey,
     );
 
     // Calculate the signature length as a 32-byte hex value

package/actions/evm/swap/types.ts

@@ -1,9 +1,14 @@
+import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
 import type {
   CreateSwapQuoteOptions,
   CreateSwapQuoteResult,
   SwapUnavailableResult,
 } from "../../../client/evm/evm.types.js";
-import type { SendEvmTransactionBodyNetwork } from "../../../openapi-client/index.js";
+import type {
+  SendEvmTransactionBodyNetwork,
+  EvmUserOperationNetwork,
+  EvmUserOperationStatus,
+} from "../../../openapi-client/index.js";
 import type { Address, Hex } from "../../../types/misc.js";
 
 /**
@@ -76,12 +81,12 @@ export interface SendSwapTransactionResult {
 /**
  * Options for creating a swap quote (account-level).
  */
-export type QuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker">;
+export type AccountQuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker">;
 
 /**
  * Result of creating a swap quote (account-level).
  */
-export type QuoteSwapResult = CreateSwapQuoteResult | SwapUnavailableResult;
+export type AccountQuoteSwapResult = CreateSwapQuoteResult | SwapUnavailableResult;
 
 /**
  * Options when providing an already created swap quote (account-level).
@@ -129,9 +134,153 @@ interface AccountInlineSwapOptions {
  * Options for executing a token swap (account-level).
  * The taker is automatically set to the account's address.
  */
-export type SwapOptions = AccountQuoteBasedSwapOptions | AccountInlineSwapOptions;
+export type AccountSwapOptions = AccountQuoteBasedSwapOptions | AccountInlineSwapOptions;
 
 /**
  * Result of executing a token swap (account-level).
  */
-export type SwapResult = SendSwapTransactionResult;
+export type AccountSwapResult = SendSwapTransactionResult;
+
+/**
+ * Options for creating a swap quote (smart account-level).
+ */
+export type SmartAccountQuoteSwapOptions = Omit<CreateSwapQuoteOptions, "taker">;
+
+/**
+ * Result of creating a swap quote (smart account-level).
+ */
+export type SmartAccountQuoteSwapResult = CreateSwapQuoteResult | SwapUnavailableResult;
+
+/**
+ * Options when providing an already created swap quote (smart account-level).
+ */
+interface SmartAccountQuoteBasedSwapOptions {
+  /**
+   * The swap quote returned by the createSwapQuote method.
+   */
+  swapQuote: CreateSwapQuoteResult;
+
+  /**
+   * Optional URL of the paymaster service to use for gas sponsorship.
+   */
+  paymasterUrl?: string;
+
+  /**
+   * Optional idempotency key for the request.
+   */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options when creating a swap quote inline (smart account-level).
+ */
+interface SmartAccountInlineSwapOptions {
+  /**
+   * The network to execute the swap on (e.g., "ethereum", "base").
+   */
+  network: SendEvmTransactionBodyNetwork;
+  /** The token to receive (destination token). */
+  toToken: Address;
+  /** The token to send (source token). */
+  fromToken: Address;
+  /** The amount to send in atomic units of the token. */
+  fromAmount: bigint;
+  /** The signer address (only needed if taker is a smart contract). */
+  signerAddress?: Address;
+  /** The gas price in Wei. */
+  gasPrice?: bigint;
+  /** The slippage tolerance in basis points (0-10000). */
+  slippageBps?: number;
+
+  /**
+   * Optional URL of the paymaster service to use for gas sponsorship.
+   */
+  paymasterUrl?: string;
+
+  /**
+   * Optional idempotency key for the request.
+   */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options for executing a token swap (smart account-level).
+ * The taker is automatically set to the smart account's address.
+ */
+export type SmartAccountSwapOptions =
+  | SmartAccountQuoteBasedSwapOptions
+  | SmartAccountInlineSwapOptions;
+
+/**
+ * Result of executing a token swap (smart account-level).
+ */
+export type SmartAccountSwapResult = {
+  /** The address of the smart wallet. */
+  smartAccountAddress: Address;
+  /** The status of the user operation. */
+  status: string;
+  /** The hash of the user operation. */
+  userOpHash: Hex;
+};
+
+/**
+ * Base options for sending a swap operation via smart account.
+ */
+interface BaseSendSwapOperationOptions {
+  /** The smart account that will execute the swap. */
+  smartAccount: EvmSmartAccount;
+  /** Optional URL of the paymaster service to use for gas sponsorship. */
+  paymasterUrl?: string;
+  /** Optional idempotency key for the request. */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options when providing an already created swap quote (for sendSwapOperation).
+ */
+interface QuoteBasedSendSwapOperationOptions extends BaseSendSwapOperationOptions {
+  /** The swap quote returned by the createSwapQuote method. */
+  swapQuote: CreateSwapQuoteResult;
+}
+
+/**
+ * Options when creating a swap quote inline (for sendSwapOperation).
+ */
+interface InlineSendSwapOperationOptions extends BaseSendSwapOperationOptions {
+  /** The network to execute the swap on. */
+  network: EvmUserOperationNetwork;
+  /** The token to receive (destination token). */
+  toToken: Address;
+  /** The token to send (source token). */
+  fromToken: Address;
+  /** The amount to send in atomic units of the token. */
+  fromAmount: bigint;
+  /** The address that will perform the swap. */
+  taker: Address;
+  /** The signer address (required since taker is a smart contract). */
+  signerAddress: Address;
+  /** The gas price in Wei. */
+  gasPrice?: bigint;
+  /** The slippage tolerance in basis points (0-10000). */
+  slippageBps?: number;
+}
+
+/**
+ * Options for sending a swap operation via smart account.
+ * Either provide a pre-created swap quote result or inline swap parameters.
+ */
+export type SendSwapOperationOptions =
+  | QuoteBasedSendSwapOperationOptions
+  | InlineSendSwapOperationOptions;
+
+/**
+ * Result of sending a swap operation via smart account.
+ */
+export type SendSwapOperationResult = {
+  /** The address of the smart wallet. */
+  smartAccountAddress: Address;
+  /** The status of the user operation. */
+  status: typeof EvmUserOperationStatus.broadcast;
+  /** The hash of the user operation. */
+  userOpHash: Hex;
+};

package/actions/evm/types.ts

@@ -13,7 +13,16 @@ import { Hex } from "../../types/misc.js";
 import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
 import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
 import type { SendTransactionOptions, TransactionResult } from "./sendTransaction.js";
-import type { SwapOptions, SwapResult, QuoteSwapOptions, QuoteSwapResult } from "./swap/types.js";
+import type {
+  AccountSwapOptions,
+  AccountSwapResult,
+  AccountQuoteSwapOptions,
+  AccountQuoteSwapResult,
+  SmartAccountSwapOptions,
+  SmartAccountSwapResult,
+  SmartAccountQuoteSwapOptions,
+  SmartAccountQuoteSwapResult,
+} from "./swap/types.js";
 import type { TransferOptions } from "./transfer/types.js";
 import type {
   WaitForUserOperationOptions,
@@ -256,11 +265,11 @@ export type AccountActions = Actions & {
    * This is useful when you need to get swap details before executing the swap.
    * The taker is automatically set to the account's address.
    *
-   * @param {QuoteSwapOptions} options - Configuration options for creating the swap quote.
+   * @param {AccountQuoteSwapOptions} options - Configuration options for creating the swap quote.
    * @param {string} options.network - The network to create the quote on
-   * @param {string} options.fromToken - The token address to sell
-   * @param {string} options.toToken - The token address to buy
-   * @param {bigint} options.fromAmount - The amount of fromToken to sell
+   * @param {string} options.fromToken - The token address to send
+   * @param {string} options.toToken - The token address to receive
+   * @param {bigint} options.fromAmount - The amount of fromToken to send
    * @param {string} [options.signerAddress] - The signer address (only needed if taker is a smart contract)
    * @param {bigint} [options.gasPrice] - The gas price in Wei
    * @param {number} [options.slippageBps] - The slippage tolerance in basis points (0-10000)
@@ -281,30 +290,33 @@ export type AccountActions = Actions & {
    * }
    * ```
    */
-  quoteSwap: (options: QuoteSwapOptions) => Promise<QuoteSwapResult>;
+  quoteSwap: (options: AccountQuoteSwapOptions) => Promise<AccountQuoteSwapResult>;
 
   /**
    * Executes a token swap on the specified network.
    * This method handles all the steps required for a swap, including Permit2 signatures if needed.
+   * The taker is automatically set to the account's address.
    *
-   * @param {SwapOptions} options - Configuration options for the swap.
-   * @param {string} [options.network] - The network to execute the swap on
-   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method.
-   * @param {CreateSwapQuoteOptions} [options.swapOptions] - Options to create a swap quote. The function will call createSwapQuote internally.
-   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request.
+   * @param {AccountSwapOptions} options - Configuration options for the swap.
+   * @param {string} [options.network] - The network to execute the swap on (required for inline swaps)
+   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method
+   * @param {string} [options.fromToken] - The token address to send (required for inline swaps)
+   * @param {string} [options.toToken] - The token address to receive (required for inline swaps)
+   * @param {bigint} [options.fromAmount] - The amount of fromToken to send (required for inline swaps)
+   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request
    *
    * @returns A promise that resolves to the transaction hash.
    *
-   * @throws {Error} If liquidity is not available when using swapOptions.
+   * @throws {Error} If liquidity is not available when using inline options.
    *
    * @example **Using a pre-created swap quote**
    * ```ts
    * // First create a swap quote
    * const swapQuote = await cdp.evm.createSwapQuote({
    *   network: "base",
-   *   buyToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
-   *   sellToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-   *   sellAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
    *   taker: account.address
    * });
    *
@@ -322,21 +334,20 @@ export type AccountActions = Actions & {
    * console.log(`Swap executed with transaction hash: ${transactionHash}`);
    * ```
    *
-   * @example **Using swap options (all-in-one)**
+   * @example **Using inline options (all-in-one)**
    * ```ts
    * // Create and execute swap in one call
    * const { transactionHash } = await account.swap({
    *   network: "base",
-   *   buyToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
-   *   sellToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
-   *   sellAmount: BigInt("1000000000000000000"), // 1 WETH in wei
-   *   taker: account.address
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
    * });
    *
    * console.log(`Swap executed with transaction hash: ${transactionHash}`);
    * ```
    */
-  swap: (options: SwapOptions) => Promise<SwapResult>;
+  swap: (options: AccountSwapOptions) => Promise<AccountSwapResult>;
 };
 
 export type SmartAccountActions = Actions & {
@@ -499,4 +510,95 @@ export type SmartAccountActions = Actions & {
   getUserOperation: (
     options: Omit<GetUserOperationOptions, "smartAccount">,
   ) => Promise<UserOperation>;
+
+  /**
+   * Creates a swap quote without executing the transaction.
+   * This is useful when you need to get swap details before executing the swap.
+   * The taker is automatically set to the smart account's address.
+   *
+   * @param {SmartAccountQuoteSwapOptions} options - Configuration options for creating the swap quote.
+   * @param {string} options.network - The network to create the quote on
+   * @param {string} options.fromToken - The token address to send
+   * @param {string} options.toToken - The token address to receive
+   * @param {bigint} options.fromAmount - The amount of fromToken to send
+   * @param {string} [options.signerAddress] - The signer address (only needed if taker is a smart contract)
+   * @param {bigint} [options.gasPrice] - The gas price in Wei
+   * @param {number} [options.slippageBps] - The slippage tolerance in basis points (0-10000)
+   *
+   * @returns A promise that resolves to the swap quote or a response indicating that liquidity is unavailable.
+   *
+   * @example
+   * ```ts
+   * const swapQuote = await smartAccount.quoteSwap({
+   *   network: "base",
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   * });
+   *
+   * if (swapQuote.liquidityAvailable) {
+   *   console.log(`Can swap for ${swapQuote.toAmount} USDC`);
+   * }
+   * ```
+   */
+  quoteSwap: (options: SmartAccountQuoteSwapOptions) => Promise<SmartAccountQuoteSwapResult>;
+
+  /**
+   * Executes a token swap on the specified network via a user operation.
+   * This method handles all the steps required for a swap, including Permit2 signatures if needed.
+   * The taker is automatically set to the smart account's address.
+   *
+   * @param {SmartAccountSwapOptions} options - Configuration options for the swap.
+   * @param {string} [options.network] - The network to execute the swap on (required for inline swaps)
+   * @param {CreateSwapQuoteResult} [options.swapQuote] - The swap quote returned by the createSwapQuote method
+   * @param {string} [options.fromToken] - The token address to send (required for inline swaps)
+   * @param {string} [options.toToken] - The token address to receive (required for inline swaps)
+   * @param {bigint} [options.fromAmount] - The amount of fromToken to send (required for inline swaps)
+   * @param {string} [options.paymasterUrl] - Optional paymaster URL for gas sponsorship
+   * @param {string} [options.idempotencyKey] - Optional idempotency key for the request
+   *
+   * @returns A promise that resolves to the user operation result.
+   *
+   * @throws {Error} If liquidity is not available when using inline options.
+   *
+   * @example **Using a pre-created swap quote**
+   * ```ts
+   * // First create a swap quote
+   * const swapQuote = await cdp.evm.createSwapQuote({
+   *   network: "base",
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   *   taker: smartAccount.address,
+   *   signerAddress: smartAccount.owners[0].address
+   * });
+   *
+   * // Check if liquidity is available
+   * if (!swapQuote.liquidityAvailable) {
+   *   console.error("Insufficient liquidity for swap");
+   *   return;
+   * }
+   *
+   * // Execute the swap
+   * const { userOpHash } = await smartAccount.swap({
+   *   swapQuote: swapQuote
+   * });
+   *
+   * console.log(`Swap executed with user op hash: ${userOpHash}`);
+   * ```
+   *
+   * @example **Using inline options (all-in-one)**
+   * ```ts
+   * // Create and execute swap in one call
+   * const { userOpHash } = await smartAccount.swap({
+   *   network: "base",
+   *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+   *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+   *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
+   * });
+   *
+   * console.log(`Swap executed with user op hash: ${userOpHash}`);
+   * ```
+   */
+  swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
 };

package/client/evm/evm.ts

@@ -1,6 +1,6 @@
 import { constants, publicEncrypt } from "crypto";
 
-import { Address } from "viem";
+import { type Address, getTypesForEIP712Domain } from "viem";
 
 import { ImportEvmAccountPublicRSAKey } from "./constants.js";
 import {
@@ -62,7 +62,10 @@ import {
 } from "../../actions/evm/waitForUserOperation.js";
 import { Analytics } from "../../analytics.js";
 import { APIError } from "../../openapi-client/errors.js";
-import { CdpOpenApiClient } from "../../openapi-client/index.js";
+import {
+  CdpOpenApiClient,
+  EIP712Message as OpenAPIEIP712Message,
+} from "../../openapi-client/index.js";
 import { Hex } from "../../types/misc.js";
 import { decryptWithPrivateKey, generateExportEncryptionKeyPair } from "../../utils/export.js";
 
@@ -978,14 +981,22 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async signTypedData(options: SignTypedDataOptions): Promise<SignatureResult> {
+    const { domain, message, primaryType } = options;
+    const types = {
+      EIP712Domain: getTypesForEIP712Domain({ domain }),
+      ...options.types,
+    };
+
+    const openApiMessage: OpenAPIEIP712Message = {
+      domain,
+      types,
+      primaryType,
+      message,
+    };
+
     const signature = await CdpOpenApiClient.signEvmTypedData(
       options.address,
-      {
-        domain: options.domain,
-        types: options.types,
-        primaryType: options.primaryType,
-        message: options.message,
-      },
+      openApiMessage,
       options.idempotencyKey,
     );