@coinbase/cdp-sdk 1.15.0 → 1.16.0

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.15.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 };
+      }
     },
   };
 

package/actions/evm/swap/getSwapPrice.ts

@@ -21,7 +21,8 @@ import { Address } from "../../../types/misc.js";
  *   toToken: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  *   fromToken: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
  *   fromAmount: BigInt("1000000000000000000"), // 1 WETH in wei
- *   taker: "0x1234567890123456789012345678901234567890"
+ *   taker: "0x1234567890123456789012345678901234567890",
+ *   idempotencyKey: "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" // Optional: for request deduplication
  * });
  * ```
  */
@@ -30,16 +31,19 @@ export async function getSwapPrice(
   options: GetSwapPriceOptions,
 ): Promise<GetSwapPriceResult | SwapUnavailableResult> {
   // Call the getEvmSwapPrice function directly with the client's configured API
-  const response = await client.getEvmSwapPrice({
-    network: options.network,
-    toToken: options.toToken,
-    fromToken: options.fromToken,
-    fromAmount: options.fromAmount.toString(),
-    taker: options.taker,
-    signerAddress: options.signerAddress,
-    gasPrice: options.gasPrice?.toString(),
-    slippageBps: options.slippageBps,
-  });
+  const response = await client.getEvmSwapPrice(
+    {
+      network: options.network,
+      toToken: options.toToken,
+      fromToken: options.fromToken,
+      fromAmount: options.fromAmount.toString(),
+      taker: options.taker,
+      signerAddress: options.signerAddress,
+      gasPrice: options.gasPrice?.toString(),
+      slippageBps: options.slippageBps,
+    },
+    options.idempotencyKey,
+  );
 
   // Check if liquidity is unavailable
   if (!response.liquidityAvailable) {