@coinbase/cdp-sdk 1.7.0 → 1.9.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.7.0";
+export declare const version = "1.9.0";
 //# sourceMappingURL=version.d.ts.map

package/accounts/evm/toEvmServerAccount.ts

@@ -1,4 +1,4 @@
-import { type Hex, type TransactionSerializable, serializeTransaction } from "viem";
+import { type TransactionSerializable, serializeTransaction } from "viem";
 
 import {
   listTokenBalances,
@@ -15,10 +15,12 @@ import { accountTransferStrategy } from "../../actions/evm/transfer/accountTrans
 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 {
+  SendTransactionOptions,
+  TransactionResult,
+} from "../../actions/evm/sendTransaction.js";
 import type { CdpOpenApiClientType, EvmAccount } from "../../openapi-client/index.js";
-import type { Address, Hash } from "../../types/misc.js";
+import type { Address, EIP712Message, Hash, Hex } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmAccount to a EvmServerAccount.
@@ -64,10 +66,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> {
+    async transfer(transferArgs): Promise<TransactionResult> {
       return transfer(apiClient, account, transferArgs, accountTransferStrategy);
     },
     async listTokenBalances(
@@ -94,6 +97,7 @@ export function toEvmServerAccount(
     },
     name: options.account.name,
     type: "evm-server",
+    policies: options.account.policies,
   };
 
   return account;

package/accounts/evm/toEvmSmartAccount.ts

@@ -24,7 +24,6 @@ import {
 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,
@@ -60,7 +59,7 @@ export function toEvmSmartAccount(
   const account: EvmSmartAccount = {
     address: options.smartAccount.address as Address,
     owners: [options.owner],
-    async transfer(transferArgs): Promise<TransferResult> {
+    async transfer(transferArgs): Promise<SendUserOperationReturnType> {
       return transfer(apiClient, account, transferArgs, smartAccountTransferStrategy);
     },
     async listTokenBalances(

package/accounts/evm/types.ts

@@ -1,9 +1,10 @@
-import { SignableMessage, TransactionSerializable, TypedData, TypedDataDefinition } from "viem";
+import { SignableMessage, TransactionSerializable } from "viem";
 
 import { Prettify } from "../../types/utils.js";
 
 import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
-import type { Hash, Hex, Address } from "../../types/misc.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[];
 };
 
 /**

package/accounts/solana/toSolanaAccount.ts

@@ -2,6 +2,7 @@ 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 { transfer, type TransferOptions } from "../../actions/solana/transfer.js";
 import {
   RequestFaucetOptions,
   SignatureResult,
@@ -53,6 +54,13 @@ export function toSolanaAccount(
         address: account.address,
       });
     },
+    policies: options.account.policies,
+    async transfer(options: Omit<TransferOptions, "from">): Promise<SignatureResult> {
+      return transfer(apiClient, {
+        ...options,
+        from: account.address,
+      });
+    },
   };
 
   return account;

package/actions/evm/transfer/accountTransferStrategy.ts

@@ -1,88 +1,48 @@
-import {
-  encodeFunctionData,
-  erc20Abi,
-  Hex,
-  TransactionReceipt,
-  WaitForTransactionReceiptTimeoutError,
-} from "viem";
+import { encodeFunctionData, erc20Abi } from "viem";
 
-import { TransferExecutionStrategy } from "./types.js";
 import { getErc20Address } from "./utils.js";
-import { EvmAccount } from "../../../accounts/evm/types.js";
 import { serializeEIP1559Transaction } from "../../../utils/serializeTransaction.js";
 
+import type { TransferExecutionStrategy } from "./types.js";
+import type { EvmAccount } from "../../../accounts/evm/types.js";
+import type { TransactionResult } from "../sendTransaction.js";
+
 export const accountTransferStrategy: TransferExecutionStrategy<EvmAccount> = {
   executeTransfer: async ({ apiClient, from, to, value, token, network }) => {
-    const transactionHash = await (async () => {
-      if (token === "eth") {
-        const result = await apiClient.sendEvmTransaction(from.address, {
-          transaction: serializeEIP1559Transaction({
-            value,
-            to,
-          }),
-          network,
-        });
-        return result.transactionHash as Hex;
-      } else {
-        const erc20Address = getErc20Address(token, network);
-
-        await apiClient.sendEvmTransaction(from.address, {
-          transaction: serializeEIP1559Transaction({
-            to: erc20Address,
-            data: encodeFunctionData({
-              abi: erc20Abi,
-              functionName: "approve",
-              args: [to, value],
-            }),
-          }),
-          network,
-        });
-
-        const result = await apiClient.sendEvmTransaction(from.address, {
-          transaction: serializeEIP1559Transaction({
-            to: erc20Address,
-            data: encodeFunctionData({
-              abi: erc20Abi,
-              functionName: "transfer",
-              args: [to, value],
-            }),
-          }),
-          network,
-        });
-
-        return result.transactionHash as Hex;
-      }
-    })();
-
-    return transactionHash;
-  },
-
-  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) {
-        throw new Error(
-          `Transaction timed out. Check the transaction on the explorer: ${publicClient.chain.blockExplorers?.default.url}/tx/${hash}`,
-        );
-      } else {
-        throw error;
-      }
+    if (token === "eth") {
+      return apiClient.sendEvmTransaction(from.address, {
+        transaction: serializeEIP1559Transaction({
+          value,
+          to,
+        }),
+        network,
+      }) as Promise<TransactionResult>;
     }
 
-    if (receipt.status === "success") {
-      return { status: receipt.status, transactionHash: hash };
-    } else {
-      throw new Error(
-        `Transaction failed. Check the transaction on the explorer: ${publicClient.chain.blockExplorers?.default.url}/tx/${hash}`,
-      );
-    }
+    const erc20Address = getErc20Address(token, network);
+
+    await apiClient.sendEvmTransaction(from.address, {
+      transaction: serializeEIP1559Transaction({
+        to: erc20Address,
+        data: encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [to, value],
+        }),
+      }),
+      network,
+    });
+
+    return apiClient.sendEvmTransaction(from.address, {
+      transaction: serializeEIP1559Transaction({
+        to: erc20Address,
+        data: encodeFunctionData({
+          abi: erc20Abi,
+          functionName: "transfer",
+          args: [to, value],
+        }),
+      }),
+      network,
+    }) as Promise<TransactionResult>;
   },
 };

package/actions/evm/transfer/smartAccountTransferStrategy.ts

@@ -1,75 +1,55 @@
 import { encodeFunctionData, erc20Abi } from "viem";
 
-import { TransferExecutionStrategy } from "./types.js";
 import { getErc20Address } from "./utils.js";
-import { EvmSmartAccount } from "../../../accounts/evm/types.js";
 import { sendUserOperation } from "../sendUserOperation.js";
-import { waitForUserOperation } from "../waitForUserOperation.js";
+
+import type { TransferExecutionStrategy } from "./types.js";
+import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
 
 export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAccount> = {
   executeTransfer: async ({ apiClient, from, to, value, token, network, paymasterUrl }) => {
-    const userOpHash = await (async () => {
-      if (token === "eth") {
-        const result = await sendUserOperation(apiClient, {
-          smartAccount: from,
-          paymasterUrl,
-          network,
-          calls: [
-            {
-              to,
-              value,
-              data: "0x",
-            },
-          ],
-        });
-        return result.userOpHash;
-      } else {
-        const erc20Address = getErc20Address(token, network);
-
-        const result = await sendUserOperation(apiClient, {
-          smartAccount: from,
-          paymasterUrl,
-          network,
-          calls: [
-            {
-              to: erc20Address,
-              data: encodeFunctionData({
-                abi: erc20Abi,
-                functionName: "approve",
-                args: [to, value],
-              }),
-            },
-            {
-              to: erc20Address,
-              data: encodeFunctionData({
-                abi: erc20Abi,
-                functionName: "transfer",
-                args: [to, value],
-              }),
-            },
-          ],
-        });
-
-        return result.userOpHash;
-      }
-    })();
-
-    return userOpHash;
-  },
+    if (token === "eth") {
+      const result = await sendUserOperation(apiClient, {
+        smartAccount: from,
+        paymasterUrl,
+        network,
+        calls: [
+          {
+            to,
+            value,
+            data: "0x",
+          },
+        ],
+      });
+      return result;
+    } else {
+      const erc20Address = getErc20Address(token, network);
 
-  waitForResult: async ({ apiClient, publicClient, from, hash, waitOptions }) => {
-    const result = await waitForUserOperation(apiClient, {
-      smartAccountAddress: from.address,
-      userOpHash: hash,
-      waitOptions,
-    });
+      const result = await sendUserOperation(apiClient, {
+        smartAccount: from,
+        paymasterUrl,
+        network,
+        calls: [
+          {
+            to: erc20Address,
+            data: encodeFunctionData({
+              abi: erc20Abi,
+              functionName: "approve",
+              args: [to, value],
+            }),
+          },
+          {
+            to: erc20Address,
+            data: encodeFunctionData({
+              abi: erc20Abi,
+              functionName: "transfer",
+              args: [to, value],
+            }),
+          },
+        ],
+      });
 
-    if (result.status === "complete") {
-      return { status: "success", transactionHash: hash };
-    } else {
-      throw new Error(
-        `Transaction failed. Check the transaction on the explorer: ${publicClient.chain.blockExplorers?.default.url}/tx/${hash}`,
-      );
+      return result;
     }
   },
 };

package/actions/evm/transfer/transfer.ts

@@ -1,15 +1,13 @@
-import { createPublicClient, http, erc20Abi, parseUnits, Address, Chain, Transport } from "viem";
-
-import { mapNetworkToChain } from "./utils.js";
-import { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
-import { CdpOpenApiClientType } from "../../../openapi-client/index.js";
-
 import type {
-  TransferResult,
   TransferExecutionStrategy,
   SmartAccountTransferOptions,
-  AccountTransferOptions,
+  TransferOptions,
 } from "./types.js";
+import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type { CdpOpenApiClientType } from "../../../openapi-client/index.js";
+import type { Address } from "../../../types/misc.js";
+import type { TransactionResult } from "../sendTransaction.js";
+import type { SendUserOperationReturnType } from "../sendUserOperation.js";
 
 /**
  * Transfer an amount of a token from an account to another account.
@@ -23,60 +21,21 @@ import type {
 export async function transfer<T extends EvmAccount | EvmSmartAccount>(
   apiClient: CdpOpenApiClientType,
   from: T,
-  transferArgs: T extends EvmSmartAccount ? SmartAccountTransferOptions : AccountTransferOptions,
+  transferArgs: T extends EvmSmartAccount ? SmartAccountTransferOptions : TransferOptions,
   transferStrategy: TransferExecutionStrategy<T>,
-): Promise<TransferResult> {
-  const publicClient = createPublicClient<Transport, Chain>({
-    chain: mapNetworkToChain(transferArgs.network),
-    transport: http(),
-  });
-
+): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult> {
   const to =
     typeof transferArgs.to === "string" ? transferArgs.to : (transferArgs.to.address as Address);
 
-  const value = await (async () => {
-    // user supplied a bigint. otherwise, we need to convert the amount to a bigint
-    if (typeof transferArgs.amount !== "string") {
-      return transferArgs.amount;
-    }
-
-    const decimals = await (async () => {
-      if (transferArgs.token === "eth") {
-        return 18;
-      } else if (transferArgs.token === "usdc") {
-        return 6;
-      } else {
-        return publicClient.readContract({
-          address: transferArgs.token,
-          abi: erc20Abi,
-          functionName: "decimals",
-          args: [],
-        });
-      }
-    })();
-
-    return parseUnits(transferArgs.amount, decimals);
-  })();
-
   const transfer = {
     apiClient,
     from,
     to,
-    value,
+    value: transferArgs.amount,
     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;
+  return transferStrategy.executeTransfer(transfer);
 }

package/actions/evm/transfer/types.ts

@@ -1,21 +1,12 @@
-import {
-  Hex,
-  TransactionReceipt,
-  Address,
-  PublicClient,
-  Chain,
-  Transport,
-  WaitForTransactionReceiptParameters,
-} from "viem";
-
-import {
+import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type {
   CdpOpenApiClientType,
   EvmUserOperationNetwork,
   SendEvmTransactionBodyNetwork,
 } from "../../../openapi-client/index.js";
-
-import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
-import type { WaitForUserOperationOptions } from "../waitForUserOperation.js";
+import type { TransactionResult } from "../sendTransaction.js";
+import type { SendUserOperationReturnType } from "../sendUserOperation.js";
+import type { Hex, Address } from "viem";
 
 /**
  * The network to transfer the token on.
@@ -25,55 +16,25 @@ export type Network = SendEvmTransactionBodyNetwork | EvmUserOperationNetwork;
 /**
  * The options for the transfer.
  */
-type TransferOptions = {
+export type TransferOptions = {
   /** The account to transfer the token to. */
   to: EvmAccount | Address;
   /**
-   * The amount of the token to transfer.
-   * If a string is provided, it will be parsed into a bigint based on the token's decimals.
+   * The amount of the token to transfer, represented as an atomic value.
    */
-  amount: bigint | string;
+  amount: bigint;
   /** The token to transfer. Can be a contract address or a predefined token name. */
   token: "eth" | "usdc" | Hex;
   /** The network to transfer the token on. */
   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.
- */
-export type TransferResult = {
-  /** The status of the transaction. */
-  status: TransactionReceipt["status"];
-  /** The transaction hash of the transfer. */
-  transactionHash: Hex;
 };
 
 /**
@@ -101,24 +62,5 @@ export interface TransferExecutionStrategy<T extends EvmAccount | EvmSmartAccoun
       token: TransferOptions["token"];
       network: TransferOptions["network"];
     } & (T extends EvmSmartAccount ? { paymasterUrl?: string } : object),
-  ): Promise<Hex>;
-
-  /**
-   * Waits for the result of the transfer.
-   *
-   * @param args - The arguments for the transfer.
-   * @param args.apiClient - The API client to use for the transfer.
-   * @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: {
-    apiClient: CdpOpenApiClientType;
-    publicClient: PublicClient<Transport, Chain>;
-    from: T;
-    hash: Hex;
-    waitOptions?: WaitForUserOperationOptions["waitOptions"];
-  }): Promise<TransferResult>;
+  ): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult>;
 }