@coinbase/cdp-sdk 1.14.0 → 1.16.0

package/_types/client/solana/solana.d.ts

@@ -1,4 +1,4 @@
-import { CreateAccountOptions, GetAccountOptions, GetOrCreateAccountOptions, ListAccountsOptions, ListAccountsResult, RequestFaucetOptions, SignatureResult, SignMessageOptions, SignTransactionOptions, SolanaClientInterface, UpdateSolanaAccountOptions } from "./solana.types.js";
+import { CreateAccountOptions, ExportAccountOptions, GetAccountOptions, GetOrCreateAccountOptions, ListAccountsOptions, ListAccountsResult, RequestFaucetOptions, SignatureResult, SignMessageOptions, SignTransactionOptions, SolanaClientInterface, UpdateSolanaAccountOptions } from "./solana.types.js";
 import { SolanaAccount } from "../../accounts/solana/types.js";
 /**
  * The namespace containing all Solana methods.
@@ -35,6 +35,31 @@ export declare class SolanaClient implements SolanaClientInterface {
      *          ```
      */
     createAccount(options?: CreateAccountOptions): Promise<SolanaAccount>;
+    /**
+     * Exports a CDP Solana account's private key.
+     * It is important to store the private key in a secure place after it's exported.
+     *
+     * @param {ExportAccountOptions} options - Parameters for exporting the Solana account.
+     * @param {string} [options.address] - The address of the account.
+     * @param {string} [options.name] - The name of the account.
+     *
+     * @returns A promise that resolves to the exported account's full 64-byte private key as a base58 encoded string.
+     *
+     * @example **With an address**
+     * ```ts
+     * const privateKey = await cdp.solana.exportAccount({
+     *   address: "1234567890123456789012345678901234567890",
+     * });
+     * ```
+     *
+     * @example **With a name**
+     * ```ts
+     * const privateKey = await cdp.solana.exportAccount({
+     *   name: "MyAccount",
+     * });
+     * ```
+     */
+    exportAccount(options: ExportAccountOptions): Promise<string>;
     /**
      * Gets a Solana account by its address.
      *

package/_types/client/solana/solana.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../../client/solana/solana.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAQ/D;;GAEG;AACH,qBAAa,YAAa,YAAW,qBAAqB;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB/E;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC;IAsBpE;;;;;;;;;;;;;;OAcG;IACG,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IA0BpF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAoBlF;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC;IAI5E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAIhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,aAAa,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,aAAa,CAAC;CAejF"}
+{"version":3,"file":"solana.d.ts","sourceRoot":"","sources":["../../../client/solana/solana.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,oBAAoB,EACpB,oBAAoB,EACpB,iBAAiB,EACjB,yBAAyB,EACzB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,eAAe,EACf,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,0BAA0B,EAC3B,MAAM,mBAAmB,CAAC;AAE3B,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAa/D;;GAEG;AACH,qBAAa,YAAa,YAAW,qBAAqB;IACxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,aAAa,CAAC,OAAO,GAAE,oBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IAkB/E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,MAAM,CAAC;IA+BnE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,UAAU,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,aAAa,CAAC;IAsBpE;;;;;;;;;;;;;;OAcG;IACG,kBAAkB,CAAC,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,aAAa,CAAC;IA0BpF;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACG,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAoBlF;;;;;;;;;;;;;;;;;OAiBG;IACG,aAAa,CAAC,OAAO,EAAE,oBAAoB,GAAG,OAAO,CAAC,eAAe,CAAC;IAI5E;;;;;;;;;;;;;;;;;;;;;OAqBG;IACG,WAAW,CAAC,OAAO,EAAE,kBAAkB,GAAG,OAAO,CAAC,eAAe,CAAC;IAIxE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAgCG;IACG,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,eAAe,CAAC;IAIhF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACG,aAAa,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,aAAa,CAAC;CAejF"}

package/_types/client/solana/solana.types.d.ts

@@ -5,6 +5,7 @@ import { OpenApiSolanaMethods, UpdateSolanaAccountBody } from "../../openapi-cli
  */
 export type SolanaClientInterface = Omit<typeof OpenApiSolanaMethods, "createSolanaAccount" | "getSolanaAccount" | "getSolanaAccountByName" | "updateSolanaAccount" | "listSolanaAccounts" | "requestSolanaFaucet" | "signSolanaMessage" | "signSolanaTransaction" | "updateSolanaAccount" | "exportSolanaAccount" | "exportSolanaAccountByName"> & {
     createAccount: (options: CreateAccountOptions) => Promise<Account>;
+    exportAccount: (options: ExportAccountOptions) => Promise<string>;
     getAccount: (options: GetAccountOptions) => Promise<Account>;
     getOrCreateAccount: (options: GetOrCreateAccountOptions) => Promise<Account>;
     updateAccount: (options: UpdateSolanaAccountOptions) => Promise<Account>;
@@ -31,6 +32,17 @@ export interface CreateAccountOptions {
     /** The idempotency key. */
     idempotencyKey?: string;
 }
+/**
+ * Options for exporting a Solana account.
+ */
+export interface ExportAccountOptions {
+    /** The address of the account. */
+    address?: string;
+    /** The name of the account. */
+    name?: string;
+    /** The idempotency key. */
+    idempotencyKey?: string;
+}
 /**
  * Options for getting a Solana account.
  */

package/_types/client/solana/solana.types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"solana.types.d.ts","sourceRoot":"","sources":["../../../client/solana/solana.types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAE9F;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG,IAAI,CACtC,OAAO,oBAAoB,EACzB,qBAAqB,GACrB,kBAAkB,GAClB,wBAAwB,GACxB,qBAAqB,GACrB,oBAAoB,GACpB,qBAAqB,GACrB,mBAAmB,GACnB,uBAAuB,GACvB,qBAAqB,GACrB,qBAAqB,GACrB,2BAA2B,CAC9B,GAAG;IACF,aAAa,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACnE,UAAU,EAAE,CAAC,OAAO,EAAE,iBAAiB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7D,kBAAkB,EAAE,CAAC,OAAO,EAAE,yBAAyB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IAC7E,aAAa,EAAE,CAAC,OAAO,EAAE,0BAA0B,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACzE,YAAY,EAAE,CAAC,OAAO,EAAE,mBAAmB,KAAK,OAAO,CAAC,kBAAkB,CAAC,CAAC;IAC5E,aAAa,EAAE,CAAC,OAAO,EAAE,oBAAoB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC3E,WAAW,EAAE,CAAC,OAAO,EAAE,kBAAkB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IACvE,eAAe,EAAE,CAAC,OAAO,EAAE,sBAAsB,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;CAChF,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,qBAAqB;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,6CAA6C;IAC7C,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,+BAA+B;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,yBAAyB;IACxC,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IACzC,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,0CAA0C;IAC1C,MAAM,EAAE,uBAAuB,CAAC;IAChC,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qBAAqB;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,sBAAsB;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,oBAAoB;IACpB,QAAQ,EAAE,aAAa,EAAE,CAAC;IAC1B;;OAEG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,sCAAsC;IACtC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;IACtB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,kCAAkC;IAClC,OAAO,EAAE,MAAM,CAAC;IAChB,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,2BAA2B;IAC3B,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB"}
+{"version":3,"file":"solana.types.d.ts","sourceRoot":"","sources":["../../../client/solana/solana.types.ts"],"names":[],"mappings":"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"}

package/_types/utils/export.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Generates a new RSA key pair with 4096-bit private key.
+ * - Private key in PKCS1 DER format
+ * - Public key in PKIX/SPKI DER format
+ *
+ * @returns A promise that resolves to the generated key pair, or rejects with an error.
+ */
+export declare const generateExportEncryptionKeyPair: () => Promise<{
+    publicKey: string;
+    privateKey: string;
+}>;
+/**
+ * Decrypts a ciphertext using RSA-OAEP-SHA256.
+ * - Parses PKCS1 private key
+ * - Uses RSA-OAEP-SHA256 for decryption
+ * - Returns hex-encoded result
+ *
+ * @param b64PrivateKey - The base64-encoded private key in PKCS1 DER format.
+ * @param b64Cipher - The base64-encoded ciphertext.
+ * @returns The decrypted key hex string, or throws an error if decryption fails.
+ */
+export declare const decryptWithPrivateKey: (b64PrivateKey: string, b64Cipher: string) => string;
+/**
+ * Format a private key to a base58 string for easy import into Solana wallet apps.
+ *
+ * @param privateKey - The private key as a hex string
+ * @returns The formatted private key as a base58 string
+ */
+export declare const formatSolanaPrivateKey: (privateKey: string) => string;
+//# sourceMappingURL=export.d.ts.map

package/_types/utils/export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"export.d.ts","sourceRoot":"","sources":["../../utils/export.ts"],"names":[],"mappings":"AAKA;;;;;;GAMG;AACH,eAAO,MAAM,+BAA+B;eAE7B,MAAM;gBACL,MAAM;EA0BrB,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,GAAI,eAAe,MAAM,EAAE,WAAW,MAAM,KAAG,MAsBhF,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,sBAAsB,GAAI,YAAY,MAAM,KAAG,MAK3D,CAAC"}

package/_types/utils/uuidV4.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Deterministically generates a UUIDv4 from a given input string.
+ * This is necessary when we need to generate downstream idempotency keys for operations that have multiple calls.
+ *
+ * @param input - The input string to derive from
+ * @param salt - Optional salt to append to the input (defaults to "salt")
+ * @returns A UUIDv4 formatted string
+ */
+export declare function createDeterministicUuidV4(input: string, salt?: string): string;
+//# sourceMappingURL=uuidV4.d.ts.map

package/_types/utils/uuidV4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuidV4.d.ts","sourceRoot":"","sources":["../../utils/uuidV4.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,SAAS,GAAG,MAAM,CAY9E"}

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.14.0";
+export declare const version = "1.16.0";
 //# sourceMappingURL=version.d.ts.map

package/accounts/evm/toEvmServerAccount.ts

@@ -1,4 +1,11 @@
-import { type TransactionSerializable, getTypesForEIP712Domain, serializeTransaction } from "viem";
+import {
+  type TransactionSerializable,
+  type TypedDataDefinition,
+  type TypedData,
+  type HashTypedDataParameters,
+  getTypesForEIP712Domain,
+  serializeTransaction,
+} from "viem";
 
 import { FundOptions, fund } from "../../actions/evm/fund/fund.js";
 import { Quote } from "../../actions/evm/fund/Quote.js";
@@ -31,13 +38,13 @@ import type {
   TransactionResult,
 } from "../../actions/evm/sendTransaction.js";
 import type {
-  SwapOptions,
-  SwapResult,
-  QuoteSwapOptions,
-  QuoteSwapResult,
+  AccountSwapOptions,
+  AccountSwapResult,
+  AccountQuoteSwapOptions,
+  AccountQuoteSwapResult,
 } from "../../actions/evm/swap/types.js";
 import type { CdpOpenApiClientType, EvmAccount } from "../../openapi-client/index.js";
-import type { Address, EIP712Message, Hash, Hex } from "../../types/misc.js";
+import type { Address, EIP712Domain, Hash, Hex } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
@@ -83,13 +90,24 @@ export function toEvmServerAccount(
       return result.signedTransaction as Hex;
     },
 
-    async signTypedData(message: EIP712Message) {
-      if (!message.types.EIP712Domain) {
-        message.types.EIP712Domain = getTypesForEIP712Domain({
-          domain: message.domain,
-        });
-      }
-      const result = await apiClient.signEvmTypedData(options.account.address, message);
+    async signTypedData<
+      const typedData extends TypedData | Record<string, unknown>,
+      primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+    >(parameters: TypedDataDefinition<typedData, primaryType>) {
+      const { domain = {}, message, primaryType } = parameters as HashTypedDataParameters;
+      const types = {
+        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        ...parameters.types,
+      };
+
+      const openApiMessage = {
+        domain: domain as EIP712Domain,
+        types,
+        primaryType,
+        message,
+      };
+
+      const result = await apiClient.signEvmTypedData(options.account.address, openApiMessage);
       return result.signature as Hex;
     },
     async transfer(transferArgs): Promise<TransactionResult> {
@@ -134,13 +152,13 @@ export function toEvmServerAccount(
     ): Promise<WaitForFundOperationResult> {
       return waitForFundOperationReceipt(apiClient, options);
     },
-    async quoteSwap(options: QuoteSwapOptions): Promise<QuoteSwapResult> {
+    async quoteSwap(options: AccountQuoteSwapOptions): Promise<AccountQuoteSwapResult> {
       return createSwapQuote(apiClient, {
         ...options,
         taker: this.address,
       });
     },
-    async swap(options: SwapOptions): Promise<SwapResult> {
+    async swap(options: AccountSwapOptions): Promise<AccountSwapResult> {
       return sendSwapTransaction(apiClient, {
         ...options,
         address: this.address,

package/accounts/evm/toEvmSmartAccount.ts

@@ -23,6 +23,8 @@ import {
   type SendUserOperationReturnType,
   sendUserOperation,
 } from "../../actions/evm/sendUserOperation.js";
+import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
+import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
 import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
 import { transfer } from "../../actions/evm/transfer/transfer.js";
 import {
@@ -33,6 +35,12 @@ import {
 import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
 
 import type { EvmAccount, EvmSmartAccount } from "./types.js";
+import type {
+  SmartAccountQuoteSwapOptions,
+  SmartAccountQuoteSwapResult,
+  SmartAccountSwapOptions,
+  SmartAccountSwapResult,
+} from "../../actions/evm/swap/types.js";
 import type {
   CdpOpenApiClientType,
   EvmSmartAccount as EvmSmartAccountModel,
@@ -128,6 +136,23 @@ export function toEvmSmartAccount(
     ): Promise<WaitForFundOperationResult> {
       return waitForFundOperationReceipt(apiClient, options);
     },
+    async quoteSwap(options: SmartAccountQuoteSwapOptions): Promise<SmartAccountQuoteSwapResult> {
+      return createSwapQuote(apiClient, {
+        ...options,
+        taker: this.address, // Always use smart account's address as taker
+        signerAddress: this.owners[0].address, // Always use owner's address as signer
+        smartAccount: account, // Pass smart account for execute method support
+      });
+    },
+    async swap(options: SmartAccountSwapOptions): Promise<SmartAccountSwapResult> {
+      return sendSwapOperation(apiClient, {
+        ...options,
+        smartAccount: account,
+        taker: this.address, // Always use smart account's address as taker
+        signerAddress: this.owners[0].address, // Always use owner's address as signer
+      });
+    },
+
     name: options.smartAccount.name,
     type: "evm-smart",
   };

package/accounts/evm/types.ts

@@ -1,9 +1,12 @@
-import { SignableMessage, TransactionSerializable } from "viem";
-
-import { Prettify } from "../../types/utils.js";
-
 import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
-import type { Address, EIP712Message, Hash, Hex } from "../../types/misc.js";
+import type { Address, Hash, Hex } from "../../types/misc.js";
+import type { Prettify } from "../../types/utils.js";
+import type {
+  SignableMessage,
+  TransactionSerializable,
+  TypedData,
+  TypedDataDefinition,
+} from "viem";
 
 /**
  * Base type for any Ethereum account with signing capabilities.
@@ -19,7 +22,12 @@ export type EvmAccount = {
   /** Signs a transaction and returns the signed transaction as a hex string. */
   signTransaction: (transaction: TransactionSerializable) => Promise<Hex>;
   /** Signs a typed data and returns the signature as a hex string. */
-  signTypedData: (message: EIP712Message) => Promise<Hex>;
+  signTypedData: <
+    const typedData extends TypedData | Record<string, unknown>,
+    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
+  >(
+    parameters: TypedDataDefinition<typedData, primaryType>,
+  ) => Promise<Hex>;
   /** A list of Policy ID's that apply to the account. */
   policies?: string[];
 };

package/actions/evm/signAndWrapTypedDataForSmartAccount.ts

@@ -0,0 +1,246 @@
+import { encodeAbiParameters, encodePacked, hashTypedData, sliceHex } from "viem";
+
+import type { EvmSmartAccount } from "../../accounts/evm/types.js";
+import type {
+  CdpOpenApiClientType,
+  EIP712Message as OpenApiEIP712Message,
+} from "../../openapi-client/index.js";
+import type { EIP712Message, Hex } from "../../types/misc.js";
+
+/**
+ * Options for signing and wrapping EIP-712 typed data with a smart account.
+ */
+export interface SignAndWrapTypedDataForSmartAccountOptions {
+  /** The smart account to sign with. */
+  smartAccount: EvmSmartAccount;
+  /** The chain ID for the signature (used for replay protection). */
+  chainId: bigint;
+  /** The EIP-712 typed data message to sign. */
+  typedData: EIP712Message;
+  /** The index of the owner to sign with (defaults to 0). */
+  ownerIndex?: bigint;
+  /** Optional idempotency key for the signing request. */
+  idempotencyKey?: string;
+}
+
+/**
+ * Result of signing and wrapping typed data for a smart account.
+ */
+export interface SignAndWrapTypedDataForSmartAccountResult {
+  /** The signature ready for smart contract use. */
+  signature: Hex;
+}
+
+/**
+ * Signs and wraps an EIP-712 message for a smart account using the required Coinbase Smart Wallet signature format.
+ *
+ * **Important: Coinbase Smart Wallet Contract Requirements**
+ *
+ * Due to the Coinbase Smart Wallet contract implementation (ERC-1271), CDP Smart Wallets have
+ * specific requirements for EIP-712 message signing:
+ *
+ * 1. **Replay-Safe Hashing**: All typed messages must be wrapped in a replay-safe hash that
+ *    includes the chain ID and smart account address. This prevents the same signature from
+ *    being valid across different chains or accounts.
+ *
+ * 2. **Signature Wrapping**: The resulting signature must be wrapped in a `SignatureWrapper`
+ *    struct that identifies which owner signed and contains the signature data in the format
+ *    expected by the smart contract's `isValidSignature()` method.
+ *
+ * This function handles both requirements automatically, making it safe and convenient for
+ * developers to sign EIP-712 messages with CDP Smart Wallets.
+ *
+ * @param {CdpOpenApiClientType} client - The CDP API client
+ * @param {SignAndWrapTypedDataForSmartAccountOptions} options - Parameters for signing and wrapping the EIP-712 message.
+ * @returns A promise that resolves to the signature that can be used with smart contracts.
+ *
+ * @example
+ * ```ts
+ * const result = await signAndWrapTypedDataForSmartAccount(client, {
+ *   smartAccount: smartAccount,
+ *   chainId: 1n,
+ *   typedData: {
+ *     domain: {
+ *       name: "Permit2",
+ *       chainId: 1,
+ *       verifyingContract: "0x000000000022D473030F116dDEE9F6B43aC78BA3",
+ *     },
+ *     types: {
+ *       EIP712Domain: [
+ *         { name: "name", type: "string" },
+ *         { name: "chainId", type: "uint256" },
+ *         { name: "verifyingContract", type: "address" },
+ *       ],
+ *       PermitTransferFrom: [
+ *         { name: "permitted", type: "TokenPermissions" },
+ *         { name: "spender", type: "address" },
+ *         { name: "nonce", type: "uint256" },
+ *         { name: "deadline", type: "uint256" },
+ *       ],
+ *       TokenPermissions: [
+ *         { name: "token", type: "address" },
+ *         { name: "amount", type: "uint256" },
+ *       ],
+ *     },
+ *     primaryType: "PermitTransferFrom",
+ *     message: {
+ *       permitted: {
+ *         token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+ *         amount: "1000000",
+ *       },
+ *       spender: "0xFfFfFfFFfFFfFFfFFfFFFFFffFFFffffFfFFFfFf",
+ *       nonce: "0",
+ *       deadline: "1717123200",
+ *     },
+ *   },
+ * });
+ *
+ * // Use result.signature for smart contract calls
+ * console.log(`Signature: ${result.signature}`);
+ * ```
+ */
+export async function signAndWrapTypedDataForSmartAccount(
+  client: CdpOpenApiClientType,
+  options: SignAndWrapTypedDataForSmartAccountOptions,
+): Promise<SignAndWrapTypedDataForSmartAccountResult> {
+  const { smartAccount, chainId, typedData, ownerIndex = 0n } = options;
+
+  // Create the replay-safe typed data
+  const replaySafeTypedData = createReplaySafeTypedData({
+    typedData,
+    chainId,
+    smartAccountAddress: smartAccount.address as Hex,
+  });
+
+  // Sign the replay-safe typed data with the smart account owner
+  const owner = smartAccount.owners[Number(ownerIndex)];
+  const signature = await client.signEvmTypedData(
+    owner.address,
+    replaySafeTypedData,
+    options.idempotencyKey,
+  );
+
+  // Wrap the signature in the format expected by the smart contract
+  const wrappedSignature = createSmartAccountSignatureWrapper({
+    signatureHex: signature.signature as Hex,
+    ownerIndex,
+  });
+
+  return {
+    signature: wrappedSignature as Hex,
+  };
+}
+
+/**
+ * Creates a replay-safe EIP-712 typed data structure by wrapping the original typed data with
+ * chain ID and smart account address.
+ *
+ * **Coinbase Smart Wallet Requirement**: Due to the Coinbase Smart Wallet contract's ERC-1271
+ * implementation, all EIP-712 messages must be wrapped in a replay-safe hash before signing.
+ * This prevents signature replay attacks across different chains or smart account addresses.
+ *
+ * The smart contract's `isValidSignature()` method expects signatures to be validated against
+ * this replay-safe hash, not the original message hash.
+ *
+ * @param params - The replay-safe hash parameters
+ * @param params.typedData - The original EIP-712 typed data to make replay-safe
+ * @param params.chainId - The chain ID for replay protection
+ * @param params.smartAccountAddress - The smart account address for additional context
+ * @returns The EIP-712 typed data structure for the replay-safe hash
+ */
+export function createReplaySafeTypedData({
+  typedData,
+  chainId,
+  smartAccountAddress,
+}: {
+  typedData: EIP712Message;
+  chainId: bigint;
+  smartAccountAddress: Hex;
+}): OpenApiEIP712Message {
+  // First hash the original typed data
+  const originalHash = hashTypedData(typedData);
+
+  // Create and return the replay-safe typed data structure
+  return {
+    domain: {
+      name: "Coinbase Smart Wallet",
+      version: "1",
+      chainId: Number(chainId),
+      verifyingContract: smartAccountAddress,
+    },
+    types: {
+      EIP712Domain: [
+        { name: "name", type: "string" },
+        { name: "version", type: "string" },
+        { name: "chainId", type: "uint256" },
+        { name: "verifyingContract", type: "address" },
+      ],
+      CoinbaseSmartWalletMessage: [{ name: "hash", type: "bytes32" }],
+    },
+    primaryType: "CoinbaseSmartWalletMessage" as const,
+    message: {
+      hash: originalHash,
+    },
+  };
+}
+
+/**
+ * Builds a signature wrapper for Coinbase Smart Wallets by decomposing a hex signature
+ * into r, s, v components and encoding them in the format expected by the smart contract.
+ *
+ * All signatures on Coinbase Smart Wallets must be wrapped in this format to identify
+ * which owner signed and provide the signature data.
+ *
+ * @param params - The signature parameters
+ * @param params.signatureHex - The hex signature to wrap (65 bytes: r + s + v)
+ * @param params.ownerIndex - The index of the owner that signed (from MultiOwnable.ownerAtIndex)
+ * @returns The encoded signature wrapper in the format expected by the smart contract
+ */
+export function createSmartAccountSignatureWrapper({
+  signatureHex,
+  ownerIndex,
+}: {
+  signatureHex: Hex;
+  ownerIndex: bigint;
+}): Hex {
+  // Decompose 65-byte hex signature into r (32 bytes), s (32 bytes), v (1 byte)
+  const r = sliceHex(signatureHex, 0, 32);
+  const s = sliceHex(signatureHex, 32, 64);
+  const v = Number(`0x${signatureHex.slice(130, 132)}`); // 130 = 2 + 64 + 64
+
+  const signatureData = encodePacked(["bytes32", "bytes32", "uint8"], [r, s, v]);
+
+  return encodeAbiParameters(
+    [SignatureWrapperStruct],
+    [
+      {
+        ownerIndex: Number(ownerIndex),
+        signatureData,
+      },
+    ],
+  ) as Hex;
+}
+
+/**
+ * The ABI structure for the SignatureWrapper struct expected by Coinbase Smart Wallets.
+ * This matches the struct defined in the smart contract:
+ *
+ * struct SignatureWrapper {
+ *   uint256 ownerIndex;
+ *   bytes signatureData;
+ * }
+ */
+const SignatureWrapperStruct = {
+  components: [
+    {
+      name: "ownerIndex",
+      type: "uint8",
+    },
+    {
+      name: "signatureData",
+      type: "bytes",
+    },
+  ],
+  name: "SignatureWrapper",
+  type: "tuple",
+} as const;

package/actions/evm/swap/createSwapQuote.ts

@@ -1,3 +1,4 @@
+import { sendSwapOperation } from "./sendSwapOperation.js";
 import { sendSwapTransaction } from "./sendSwapTransaction.js";
 import {
   CreateSwapQuoteOptions,
@@ -10,9 +11,12 @@ import {
   CdpOpenApiClientType,
   CreateSwapQuoteResponse,
   type SendEvmTransactionBodyNetwork,
+  type EvmUserOperationNetwork,
 } from "../../../openapi-client/index.js";
 import { Address, Hex } from "../../../types/misc.js";
 
+import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
+
 /**
  * Creates a quote for a swap between two tokens on an EVM network.
  *
@@ -45,16 +49,19 @@ export async function createSwapQuote(
   const taker = options.taker as Address;
 
   // Call the createEvmSwapQuote function directly with the client's configured API
-  const response = await client.createEvmSwapQuote({
-    network: options.network,
-    toToken: options.toToken,
-    fromToken: options.fromToken,
-    fromAmount: options.fromAmount.toString(),
-    taker: taker,
-    signerAddress: options.signerAddress,
-    gasPrice: options.gasPrice?.toString(),
-    slippageBps: options.slippageBps,
-  });
+  const response = await client.createEvmSwapQuote(
+    {
+      network: options.network,
+      toToken: options.toToken,
+      fromToken: options.fromToken,
+      fromAmount: options.fromAmount.toString(),
+      taker: taker,
+      signerAddress: options.signerAddress,
+      gasPrice: options.gasPrice?.toString(),
+      slippageBps: options.slippageBps,
+    },
+    options.idempotencyKey,
+  );
 
   // Check if liquidity is unavailable
   if (!response.liquidityAvailable) {
@@ -134,13 +141,31 @@ export async function createSwapQuote(
     execute: async (
       executeOptions: ExecuteSwapQuoteOptions = {},
     ): Promise<ExecuteSwapQuoteResult> => {
-      const { transactionHash } = await sendSwapTransaction(client, {
-        address: options.signerAddress || taker, // Use signerAddress for smart accounts, taker for EOAs
-        network: result.network as SendEvmTransactionBodyNetwork,
-        swapQuote: result,
-        idempotencyKey: executeOptions.idempotencyKey,
-      });
-      return { transactionHash };
+      if (options.smartAccount) {
+        // Smart account execution - use sendSwapOperation
+        const userOpResult = await sendSwapOperation(client, {
+          smartAccount: options.smartAccount as EvmSmartAccount,
+          network: result.network as EvmUserOperationNetwork,
+          swapQuote: result,
+          idempotencyKey: executeOptions.idempotencyKey,
+        });
+
+        return {
+          userOpHash: userOpResult.userOpHash,
+          smartAccountAddress: userOpResult.smartAccountAddress,
+          status: userOpResult.status,
+        };
+      } else {
+        // EOA execution - use sendSwapTransaction
+        const { transactionHash } = await sendSwapTransaction(client, {
+          address: taker,
+          network: result.network as SendEvmTransactionBodyNetwork,
+          swapQuote: result,
+          idempotencyKey: executeOptions.idempotencyKey,
+        });
+
+        return { transactionHash };
+      }
     },
   };