@coinbase/cdp-sdk 1.6.0 → 1.8.0

package/_types/policies/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../policies/schema.ts"],"names":[],"mappings":"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"}

package/_types/policies/types.d.ts

@@ -0,0 +1,19 @@
+import { PolicyScope, Rule } from "./schema.js";
+/**
+ * A single Policy that can be used to govern the behavior of projects and accounts.
+ */
+export type Policy = {
+    /** The unique identifier for the policy. */
+    id: string;
+    /** An optional human-readable description of the policy. */
+    description?: string;
+    /** The scope of the policy. Only one project-level policy can exist at any time. */
+    scope: PolicyScope;
+    /** A list of rules that comprise the policy. */
+    rules: Rule[];
+    /** The ISO 8601 timestamp at which the Policy was created. */
+    createdAt: string;
+    /** The ISO 8601 timestamp at which the Policy was last updated. */
+    updatedAt: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/_types/policies/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../policies/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAEhD;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,4DAA4D;IAC5D,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,oFAAoF;IACpF,KAAK,EAAE,WAAW,CAAC;IACnB,gDAAgD;IAChD,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,8DAA8D;IAC9D,SAAS,EAAE,MAAM,CAAC;IAClB,mEAAmE;IACnE,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC"}

package/_types/types/misc.d.ts

@@ -38,4 +38,43 @@ export type TransactionRequestEIP1559 = {
     /** (Ignored) The transaction type is always `eip1559`. */
     type?: "eip1559" | undefined;
 };
+/**
+ * The domain of the EIP-712 typed data.
+ */
+export interface EIP712Domain {
+    /** The name of the DApp or protocol. */
+    name?: string;
+    /** The version of the DApp or protocol. */
+    version?: string;
+    /** The chain ID of the EVM network. */
+    chainId?: number;
+    /** The 0x-prefixed EVM address of the verifying smart contract. */
+    verifyingContract?: string;
+    /** The optional 32-byte 0x-prefixed hex salt for domain separation. */
+    salt?: string;
+}
+/**
+ * A mapping of struct names to an array of type objects (name + type).
+ * Each key corresponds to a type name (e.g., "`EIP712Domain`", "`PermitTransferFrom`").
+ */
+export interface EIP712Types {
+    [key: string]: unknown;
+}
+/**
+ * The message to sign. The structure of this message must match the `primaryType` struct in the `types` object.
+ */
+export type EIP712MessageMessage = {
+    [key: string]: unknown;
+};
+/**
+ * The message to sign using EIP-712.
+ */
+export interface EIP712Message {
+    domain: EIP712Domain;
+    types: EIP712Types;
+    /** The primary type of the message. This is the name of the struct in the `types` object that is the root of the message. */
+    primaryType: string;
+    /** The message to sign. The structure of this message must match the `primaryType` struct in the `types` object. */
+    message: EIP712MessageMessage;
+}
 //# sourceMappingURL=misc.d.ts.map

package/_types/types/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../types/misc.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAChC,MAAM,MAAM,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;AACjC,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG,SAAS;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,SAAS,GAAG,EAAE,CAAC;CAC7B,EAAE,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG;IACtC,yEAAyE;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACvB,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,kDAAkD;IAClD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,yFAAyF;IACzF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC9B,CAAC"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../types/misc.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAChC,MAAM,MAAM,IAAI,GAAG,KAAK,MAAM,EAAE,CAAC;AACjC,MAAM,MAAM,OAAO,GAAG,KAAK,MAAM,EAAE,CAAC;AAEpC,MAAM,MAAM,UAAU,GAAG,SAAS;IAChC,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,SAAS,GAAG,EAAE,CAAC;CAC7B,EAAE,CAAC;AAEJ,MAAM,MAAM,yBAAyB,GAAG;IACtC,yEAAyE;IACzE,EAAE,EAAE,OAAO,CAAC;IACZ,+DAA+D;IAC/D,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,2EAA2E;IAC3E,IAAI,CAAC,EAAE,GAAG,GAAG,SAAS,CAAC;IACvB,oDAAoD;IACpD,GAAG,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACzB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC;;;OAGG;IACH,oBAAoB,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1C,kDAAkD;IAClD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,gFAAgF;IAChF,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,yFAAyF;IACzF,IAAI,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IAC3B,0DAA0D;IAC1D,IAAI,CAAC,EAAE,SAAS,GAAG,SAAS,CAAC;CAC9B,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,wCAAwC;IACxC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,2CAA2C;IAC3C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,uCAAuC;IACvC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,uEAAuE;IACvE,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAC1B,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;CAAE,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,MAAM,EAAE,YAAY,CAAC;IACrB,KAAK,EAAE,WAAW,CAAC;IACnB,6HAA6H;IAC7H,WAAW,EAAE,MAAM,CAAC;IACpB,oHAAoH;IACpH,OAAO,EAAE,oBAAoB,CAAC;CAC/B"}

package/_types/version.d.ts

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

package/accounts/evm/toEvmServerAccount.ts

@@ -14,11 +14,11 @@ import { sendTransaction } from "../../actions/evm/sendTransaction.js";
 import { accountTransferStrategy } from "../../actions/evm/transfer/accountTransferStrategy.js";
 import { transfer } from "../../actions/evm/transfer/transfer.js";
 
+import type { EvmServerAccount } from "./types.js";
 import type { SendTransactionOptions } from "../../actions/evm/sendTransaction.js";
 import type { TransferResult } from "../../actions/evm/transfer/types.js";
 import type { CdpOpenApiClientType, EvmAccount } from "../../openapi-client/index.js";
-import type { Address, Hash } from "../../types/misc.js";
-import type { EvmServerAccount } from "../types.js";
+import type { Address, EIP712Message, Hash } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
@@ -64,9 +64,11 @@ export function toEvmServerAccount(
       return result.signedTransaction as Hex;
     },
 
-    async signTypedData() {
-      throw new Error("Not implemented");
+    async signTypedData(message: EIP712Message) {
+      const result = await apiClient.signEvmTypedData(options.account.address, message);
+      return result.signature as Hex;
     },
+
     async transfer(transferArgs): Promise<TransferResult> {
       return transfer(apiClient, account, transferArgs, accountTransferStrategy);
     },
@@ -94,6 +96,7 @@ export function toEvmServerAccount(
     },
     name: options.account.name,
     type: "evm-server",
+    policies: options.account.policies,
   };
 
   return account;

package/accounts/evm/toEvmSmartAccount.ts

@@ -1,3 +1,4 @@
+import { getUserOperation } from "../../actions/evm/getUserOperation.js";
 import {
   listTokenBalances,
   type ListTokenBalancesOptions,
@@ -20,14 +21,15 @@ import {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
+import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
 
+import type { EvmAccount, EvmSmartAccount } from "./types.js";
 import type { TransferResult } from "../../actions/evm/transfer/types.js";
 import type {
   CdpOpenApiClientType,
   EvmSmartAccount as EvmSmartAccountModel,
 } from "../../openapi-client/index.js";
 import type { Address } from "../../types/misc.js";
-import type { EvmAccount, EvmSmartAccount } from "../types.js";
 
 /**
  * Options for converting a pre-existing EvmSmartAccount and owner to a EvmSmartAccount
@@ -85,6 +87,14 @@ export function toEvmSmartAccount(
         smartAccountAddress: account.address,
       });
     },
+    async getUserOperation(
+      options: Omit<GetUserOperationOptions, "smartAccount">,
+    ): Promise<UserOperation> {
+      return getUserOperation(apiClient, {
+        ...options,
+        smartAccount: account,
+      });
+    },
     async requestFaucet(
       options: Omit<RequestFaucetOptions, "address">,
     ): Promise<RequestFaucetResult> {

package/accounts/{types.ts → evm/types.ts}

@@ -1,9 +1,10 @@
-import { SignableMessage, TransactionSerializable, TypedData, TypedDataDefinition } from "viem";
+import { SignableMessage, TransactionSerializable } from "viem";
 
-import { Actions } from "../actions/evm/types.js";
-import { Prettify } from "../types/utils.js";
+import { Prettify } from "../../types/utils.js";
 
-import type { Hash, Hex, Address } from "../types/misc.js";
+import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
+import type { EIP712Message } from "../../openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.js";
+import type { Address, Hash, Hex } from "../../types/misc.js";
 
 /**
  * Base type for any Ethereum account with signing capabilities.
@@ -19,12 +20,9 @@ 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: <
-    const typedData extends TypedData | Record<string, unknown>,
-    primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
-  >(
-    parameters: TypedDataDefinition<typedData, primaryType>,
-  ) => Promise<Hex>;
+  signTypedData: (message: EIP712Message) => Promise<Hex>;
+  /** A list of Policy ID's that apply to the account. */
+  policies?: string[];
 };
 
 /**
@@ -32,7 +30,7 @@ export type EvmAccount = {
  */
 export type EvmServerAccount = Prettify<
   EvmAccount &
-    Omit<Actions, "sendUserOperation" | "waitForUserOperation"> & {
+    AccountActions & {
       /** Optional name for the server account. */
       name?: string;
       /** Indicates this is a server-managed account. */
@@ -53,5 +51,5 @@ export type EvmSmartAccount = Prettify<
     owners: EvmAccount[];
     /** Identifier for the smart account type. */
     type: "evm-smart";
-  } & Omit<Actions, "sendTransaction">
+  } & SmartAccountActions
 >;

package/accounts/solana/toSolanaAccount.ts

@@ -0,0 +1,60 @@
+import { Account, SolanaAccount } from "./types.js";
+import { requestFaucet } from "../../actions/solana/requestFaucet.js";
+import { signMessage } from "../../actions/solana/signMessage.js";
+import { signTransaction } from "../../actions/solana/signTransaction.js";
+import {
+  RequestFaucetOptions,
+  SignatureResult,
+  SignMessageOptions,
+  SignTransactionOptions,
+} from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+/**
+ * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
+ */
+export type ToSolanaAccountOptions = {
+  /** The Solana account that was previously created. */
+  account: Account;
+};
+
+/**
+ * Creates a Solana account instance with actions from an existing Solana account.
+ * Use this to interact with previously deployed Solana accounts, rather than creating new ones.
+ *
+ * @param {CdpOpenApiClientType} apiClient - The API client.
+ * @param {ToSolanaAccountOptions} options - Configuration options.
+ * @param {Account} options.account - The Solana account that was previously created.
+ * @returns {SolanaAccount} A configured SolanaAccount instance ready for signing.
+ */
+export function toSolanaAccount(
+  apiClient: CdpOpenApiClientType,
+  options: ToSolanaAccountOptions,
+): SolanaAccount {
+  const account: SolanaAccount = {
+    address: options.account.address,
+    name: options.account.name,
+    async requestFaucet(options: Omit<RequestFaucetOptions, "address">): Promise<SignatureResult> {
+      return requestFaucet(apiClient, {
+        ...options,
+        address: account.address,
+      });
+    },
+    async signMessage(options: Omit<SignMessageOptions, "address">): Promise<SignatureResult> {
+      return signMessage(apiClient, {
+        ...options,
+        address: account.address,
+      });
+    },
+    async signTransaction(
+      options: Omit<SignTransactionOptions, "address">,
+    ): Promise<SignatureResult> {
+      return signTransaction(apiClient, {
+        ...options,
+        address: account.address,
+      });
+    },
+    policies: options.account.policies,
+  };
+
+  return account;
+}

package/accounts/solana/types.ts

@@ -0,0 +1,13 @@
+import { AccountActions } from "../../actions/solana/types.js";
+import { SolanaAccount as OpenAPISolanaAccount } from "../../openapi-client/index.js";
+import { Prettify } from "../../types/utils.js";
+
+/**
+ * A base Solana account.
+ */
+export type Account = OpenAPISolanaAccount;
+
+/**
+ * A Solana account with actions.
+ */
+export type SolanaAccount = Prettify<OpenAPISolanaAccount & AccountActions>;

package/actions/evm/getUserOperation.ts

@@ -0,0 +1,40 @@
+import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+import { Address, Hex } from "../../types/misc.js";
+
+/**
+ * Gets a user operation for a smart account by user operation hash.
+ *
+ * @param {CdpOpenApiClientType} client - The client to use to get the user operation.
+ * @param {GetUserOperationOptions} options - Parameters for getting the user operation.
+ * @param {SmartAccount} options.smartAccount - The smart account signing the user operation.
+ * @param {string} options.userOpHash - The user operation hash.
+ *
+ * @returns A promise that resolves to the user operation.
+ *
+ * @example
+ * ```ts
+ * const userOp = await getUserOperation(client, {
+ *   smartAccount,
+ *   userOpHash: "0x1234567890123456789012345678901234567890123456789012345678901234",
+ * });
+ * ```
+ */
+export async function getUserOperation(
+  client: CdpOpenApiClientType,
+  options: GetUserOperationOptions,
+): Promise<UserOperation> {
+  const userOp = await client.getUserOperation(options.smartAccount.address, options.userOpHash);
+
+  return {
+    calls: userOp.calls.map(call => ({
+      to: call.to as Address,
+      value: BigInt(call.value),
+      data: call.data as Hex,
+    })),
+    network: userOp.network,
+    status: userOp.status,
+    transactionHash: userOp.transactionHash as Hex | undefined,
+    userOpHash: userOp.userOpHash as Hex,
+  };
+}

package/actions/evm/sendUserOperation.ts

@@ -6,7 +6,7 @@ import {
   CdpOpenApiClientType,
 } from "../../openapi-client/index.js";
 
-import type { EvmSmartAccount } from "../../accounts/types.js";
+import type { EvmSmartAccount } from "../../accounts/evm/types.js";
 import type { Calls } from "../../types/calls.js";
 import type { Address, Hex } from "../../types/misc.js";
 

package/actions/evm/transfer/accountTransferStrategy.ts

@@ -8,23 +8,23 @@ import {
 
 import { TransferExecutionStrategy } from "./types.js";
 import { getErc20Address } from "./utils.js";
-import { EvmAccount } from "../../../accounts/types.js";
+import { EvmAccount } from "../../../accounts/evm/types.js";
 import { serializeEIP1559Transaction } from "../../../utils/serializeTransaction.js";
 
 export const accountTransferStrategy: TransferExecutionStrategy<EvmAccount> = {
-  executeTransfer: async ({ apiClient, from, transferArgs, to, value }) => {
+  executeTransfer: async ({ apiClient, from, to, value, token, network }) => {
     const transactionHash = await (async () => {
-      if (transferArgs.token === "eth") {
+      if (token === "eth") {
         const result = await apiClient.sendEvmTransaction(from.address, {
           transaction: serializeEIP1559Transaction({
             value,
             to,
           }),
-          network: transferArgs.network,
+          network,
         });
         return result.transactionHash as Hex;
       } else {
-        const erc20Address = getErc20Address(transferArgs.token, transferArgs.network);
+        const erc20Address = getErc20Address(token, network);
 
         await apiClient.sendEvmTransaction(from.address, {
           transaction: serializeEIP1559Transaction({
@@ -35,7 +35,7 @@ export const accountTransferStrategy: TransferExecutionStrategy<EvmAccount> = {
               args: [to, value],
             }),
           }),
-          network: transferArgs.network,
+          network,
         });
 
         const result = await apiClient.sendEvmTransaction(from.address, {
@@ -47,7 +47,7 @@ export const accountTransferStrategy: TransferExecutionStrategy<EvmAccount> = {
               args: [to, value],
             }),
           }),
-          network: transferArgs.network,
+          network,
         });
 
         return result.transactionHash as Hex;
@@ -57,11 +57,15 @@ export const accountTransferStrategy: TransferExecutionStrategy<EvmAccount> = {
     return transactionHash;
   },
 
-  waitForResult: async ({ publicClient, hash }) => {
+  waitForResult: async ({ publicClient, hash, waitOptions }) => {
     let receipt: TransactionReceipt;
     try {
       receipt = await publicClient.waitForTransactionReceipt({
         hash,
+        pollingInterval: waitOptions?.intervalSeconds
+          ? waitOptions.intervalSeconds * 1000
+          : undefined,
+        timeout: waitOptions?.timeoutSeconds ? waitOptions.timeoutSeconds * 1000 : undefined,
       });
     } catch (error) {
       if (error instanceof WaitForTransactionReceiptTimeoutError) {

package/actions/evm/transfer/smartAccountTransferStrategy.ts

@@ -2,17 +2,18 @@ import { encodeFunctionData, erc20Abi } from "viem";
 
 import { TransferExecutionStrategy } from "./types.js";
 import { getErc20Address } from "./utils.js";
-import { EvmSmartAccount } from "../../../accounts/types.js";
+import { EvmSmartAccount } from "../../../accounts/evm/types.js";
 import { sendUserOperation } from "../sendUserOperation.js";
 import { waitForUserOperation } from "../waitForUserOperation.js";
 
 export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAccount> = {
-  executeTransfer: async ({ apiClient, from, transferArgs, to, value }) => {
+  executeTransfer: async ({ apiClient, from, to, value, token, network, paymasterUrl }) => {
     const userOpHash = await (async () => {
-      if (transferArgs.token === "eth") {
+      if (token === "eth") {
         const result = await sendUserOperation(apiClient, {
           smartAccount: from,
-          network: transferArgs.network,
+          paymasterUrl,
+          network,
           calls: [
             {
               to,
@@ -23,11 +24,12 @@ export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAcc
         });
         return result.userOpHash;
       } else {
-        const erc20Address = getErc20Address(transferArgs.token, transferArgs.network);
+        const erc20Address = getErc20Address(token, network);
 
         const result = await sendUserOperation(apiClient, {
           smartAccount: from,
-          network: transferArgs.network,
+          paymasterUrl,
+          network,
           calls: [
             {
               to: erc20Address,
@@ -55,10 +57,11 @@ export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAcc
     return userOpHash;
   },
 
-  waitForResult: async ({ apiClient, publicClient, from, hash }) => {
+  waitForResult: async ({ apiClient, publicClient, from, hash, waitOptions }) => {
     const result = await waitForUserOperation(apiClient, {
       smartAccountAddress: from.address,
       userOpHash: hash,
+      waitOptions,
     });
 
     if (result.status === "complete") {

package/actions/evm/transfer/transfer.ts

@@ -1,10 +1,16 @@
 import { createPublicClient, http, erc20Abi, parseUnits, Address, Chain, Transport } from "viem";
 
-import { TransferResult, TransferOptions, TransferExecutionStrategy } from "./types.js";
 import { mapNetworkToChain } from "./utils.js";
-import { EvmAccount, EvmSmartAccount } from "../../../accounts/types.js";
+import { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
 import { CdpOpenApiClientType } from "../../../openapi-client/index.js";
 
+import type {
+  TransferResult,
+  TransferExecutionStrategy,
+  SmartAccountTransferOptions,
+  AccountTransferOptions,
+} from "./types.js";
+
 /**
  * Transfer an amount of a token from an account to another account.
  *
@@ -17,7 +23,7 @@ import { CdpOpenApiClientType } from "../../../openapi-client/index.js";
 export async function transfer<T extends EvmAccount | EvmSmartAccount>(
   apiClient: CdpOpenApiClientType,
   from: T,
-  transferArgs: TransferOptions,
+  transferArgs: T extends EvmSmartAccount ? SmartAccountTransferOptions : AccountTransferOptions,
   transferStrategy: TransferExecutionStrategy<T>,
 ): Promise<TransferResult> {
   const publicClient = createPublicClient<Transport, Chain>({
@@ -52,19 +58,24 @@ export async function transfer<T extends EvmAccount | EvmSmartAccount>(
     return parseUnits(transferArgs.amount, decimals);
   })();
 
-  const hash = await transferStrategy.executeTransfer({
+  const transfer = {
     apiClient,
     from,
-    transferArgs,
     to,
     value,
-  });
+    token: transferArgs.token,
+    network: transferArgs.network,
+    paymasterUrl: "paymasterUrl" in transferArgs ? transferArgs.paymasterUrl : undefined,
+  };
+
+  const hash = await transferStrategy.executeTransfer(transfer);
 
   const result = await transferStrategy.waitForResult({
     apiClient,
     publicClient,
     from,
     hash,
+    waitOptions: transferArgs.waitOptions,
   });
 
   return result;

package/actions/evm/transfer/types.ts

@@ -1,12 +1,22 @@
-import { Hex, TransactionReceipt, Address, PublicClient, Chain, Transport } from "viem";
+import {
+  Hex,
+  TransactionReceipt,
+  Address,
+  PublicClient,
+  Chain,
+  Transport,
+  WaitForTransactionReceiptParameters,
+} from "viem";
 
 import {
   CdpOpenApiClientType,
-  EvmAccount,
   EvmUserOperationNetwork,
   SendEvmTransactionBodyNetwork,
 } from "../../../openapi-client/index.js";
 
+import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type { WaitForUserOperationOptions } from "../waitForUserOperation.js";
+
 /**
  * The network to transfer the token on.
  */
@@ -29,6 +39,33 @@ export type TransferOptions = {
   network: Network;
 };
 
+/**
+ * The options for the transfer using an account.
+ */
+export type AccountTransferOptions = TransferOptions & {
+  /** The options for waiting for the result of the transfer. */
+  waitOptions?: {
+    /**
+     * Polling frequency (in seconds). Defaults to 4 seconds.
+     */
+    intervalSeconds?: WaitForTransactionReceiptParameters["pollingInterval"];
+    /**
+     * Optional timeout (in seconds) to wait before stopping polling. Defaults to 180 seconds.
+     */
+    timeoutSeconds?: WaitForTransactionReceiptParameters["timeout"];
+  };
+};
+
+/**
+ * The options for the transfer using a smart account.
+ */
+export type SmartAccountTransferOptions = TransferOptions & {
+  /** The paymaster URL to use for the transfer. */
+  paymasterUrl?: string;
+  /** The options for waiting for the result of the transfer. */
+  waitOptions?: WaitForUserOperationOptions["waitOptions"];
+};
+
 /**
  * The result of the transfer.
  */
@@ -42,25 +79,29 @@ export type TransferResult = {
 /**
  * A strategy for executing a transfer.
  */
-export interface TransferExecutionStrategy<T> {
+export interface TransferExecutionStrategy<T extends EvmAccount | EvmSmartAccount> {
   /**
    * Executes the transfer.
    *
    * @param args - The arguments for the transfer.
    * @param args.apiClient - The API client to use for the transfer.
    * @param args.from - The account to transfer the token from.
-   * @param args.transferArgs - The arguments for the transfer.
    * @param args.to - The account to transfer the token to.
    * @param args.value - The value of the transfer.
+   * @param args.token - The token to transfer.
+   * @param args.network - The network to transfer the token on.
    * @returns The transaction hash of the transfer.
    */
-  executeTransfer(args: {
-    apiClient: CdpOpenApiClientType;
-    from: T;
-    transferArgs: TransferOptions;
-    to: Address;
-    value: bigint;
-  }): Promise<Hex>;
+  executeTransfer(
+    args: {
+      apiClient: CdpOpenApiClientType;
+      from: T;
+      to: Address;
+      value: bigint;
+      token: TransferOptions["token"];
+      network: TransferOptions["network"];
+    } & (T extends EvmSmartAccount ? { paymasterUrl?: string } : object),
+  ): Promise<Hex>;
 
   /**
    * Waits for the result of the transfer.
@@ -70,6 +111,7 @@ export interface TransferExecutionStrategy<T> {
    * @param args.publicClient - The public client to use for the transfer.
    * @param args.from - The account to transfer the token from.
    * @param args.hash - The transaction hash of the transfer.
+   * @param args.waitOptions - The options for waiting for the result of the transfer.
    * @returns The result of the transfer.
    */
   waitForResult(args: {
@@ -77,5 +119,6 @@ export interface TransferExecutionStrategy<T> {
     publicClient: PublicClient<Transport, Chain>;
     from: T;
     hash: Hex;
+    waitOptions?: WaitForUserOperationOptions["waitOptions"];
   }): Promise<TransferResult>;
 }