@coinbase/cdp-sdk 1.5.0 → 1.6.0

package/actions/evm/transfer/smartAccountTransferStrategy.ts

@@ -10,7 +10,8 @@ export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAcc
   executeTransfer: async ({ apiClient, from, transferArgs, to, value }) => {
     const userOpHash = await (async () => {
       if (transferArgs.token === "eth") {
-        const result = await sendUserOperation(apiClient, from, {
+        const result = await sendUserOperation(apiClient, {
+          smartAccount: from,
           network: transferArgs.network,
           calls: [
             {
@@ -24,7 +25,8 @@ export const smartAccountTransferStrategy: TransferExecutionStrategy<EvmSmartAcc
       } else {
         const erc20Address = getErc20Address(transferArgs.token, transferArgs.network);
 
-        const result = await sendUserOperation(apiClient, from, {
+        const result = await sendUserOperation(apiClient, {
+          smartAccount: from,
           network: transferArgs.network,
           calls: [
             {

package/actions/evm/types.ts

@@ -1,5 +1,13 @@
-import { TransferOptions, TransferResult } from "./transfer/types.js";
+import { SendUserOperationReturnType, SendUserOperationOptions } from "./sendUserOperation.js";
 
+import type { ListTokenBalancesResult, ListTokenBalancesOptions } from "./listTokenBalances.js";
+import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
+import type { SendTransactionOptions, TransactionResult } from "./sendTransaction.js";
+import type { TransferOptions, TransferResult } from "./transfer/types.js";
+import type {
+  WaitForUserOperationOptions,
+  WaitForUserOperationReturnType,
+} from "./waitForUserOperation.js";
 export type Actions = {
   /**
    * Transfer an amount of a token from an account to another account.
@@ -85,4 +93,152 @@ export type Actions = {
    * ```
    */
   transfer: (options: TransferOptions) => Promise<TransferResult>;
+
+  /**
+   * List the token balances of an account.
+   *
+   * @param options - The options for the list token balances.
+   * @param options.network - The network to list the token balances on.
+   *
+   * @returns The result of the list token balances.
+   *
+   * @example
+   * ```typescript
+   * const balances = await account.listTokenBalances({
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  listTokenBalances: (
+    options: Omit<ListTokenBalancesOptions, "address">,
+  ) => Promise<ListTokenBalancesResult>;
+
+  /**
+   * Requests funds from an EVM faucet.
+   *
+   * @param {RequestFaucetOptions} options - Parameters for requesting funds from the EVM faucet.
+   * @param {string} options.network - The network to request funds from.
+   * @param {string} options.token - The token to request funds for.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the transaction hash.
+   *
+   * @example
+   * ```ts
+   * const result = await account.requestFaucet({
+   *   network: "base-sepolia",
+   *   token: "eth",
+   * });
+   * ```
+   */
+  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
+
+  /**
+   * Signs an EVM transaction and sends it to the specified network using the Coinbase API.
+   * This method handles nonce management and gas estimation automatically.
+   *
+   * @param {SendTransactionOptions} options - Configuration options for sending the transaction.
+   * @returns A promise that resolves to the transaction hash.
+   *
+   * @example
+   * **Sending an RLP-encoded transaction**
+   * ```ts
+   * import { parseEther, serializeTransaction } from "viem";
+   * import { baseSepolia } from "viem/chains";
+   *
+   * const { transactionHash } = await account.sendTransaction({
+   *   transaction: serializeTransaction({
+   *     to: "0x4252e0c9A3da5A2700e7d91cb50aEf522D0C6Fe8",
+   *     value: parseEther("0.000001"),
+   *     chainId: baseSepolia.id,
+   *     // Fields below are optional, CDP API will populate them if omitted.
+   *     // nonce
+   *     // maxPriorityFeePerGas
+   *     // maxFeePerGas
+   *     // gas
+   *   }),
+   *   network: "base-sepolia",
+   * });
+   * ```
+   * @example
+   * **Sending an EIP-1559 transaction request object**
+   * ```ts
+   * const { transactionHash } = await account.sendTransaction({
+   *   transaction: {
+   *     to: "0x4252e0c9A3da5A2700e7d91cb50aEf522D0C6Fe8",
+   *     value: parseEther("0.000001"),
+   *     // Fields below are optional, CDP API will populate them if omitted.
+   *     // nonce
+   *     // maxPriorityFeePerGas
+   *     // maxFeePerGas
+   *     // gas
+   *   },
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<TransactionResult>;
+
+  /**
+   * Sends a user operation.
+   *
+   * @param {SendUserOperationOptions} options - Parameters for sending the user operation.
+   * @param {string} options.network - The network to send the user operation on.
+   * @param {EvmCall[]} options.calls - The calls to include in the user operation.
+   * @param {string} [options.paymasterUrl] - The optional paymaster URL to use for the user operation.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to an object containing the smart account address,
+   * the user operation hash, and the status of the user operation.
+   *
+   * @example
+   * ```ts
+   * const userOp = await smartAccount.sendUserOperation({
+   *   network: "base-sepolia",
+   *   calls: [
+   *     {
+   *       to: "0x1234567890123456789012345678901234567890",
+   *       value: parseEther("0.000001"),
+   *       data: "0x",
+   *     },
+   *   ],
+   * });
+   * ```
+   */
+  sendUserOperation: (
+    options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">,
+  ) => Promise<SendUserOperationReturnType>;
+
+  /**
+   * Waits for a user operation to complete or fail.
+   *
+   * @param {WaitForUserOperationOptions} options - Parameters for waiting for the user operation.
+   * @param {string} options.userOpHash - The user operation hash.
+   * @param {WaitOptions} [options.waitOptions] - Optional parameters for the wait operation.
+   *
+   * @returns A promise that resolves to the transaction receipt.
+   *
+   * @example
+   * ```ts
+   * // Send a user operation and get the user operation hash
+   * const { userOpHash } = await smartAccount.sendUserOperation({
+   *   network: "base-sepolia",
+   *   calls: [
+   *     {
+   *       to: "0x0000000000000000000000000000000000000000",
+   *       value: parseEther("0.000001"),
+   *       data: "0x",
+   *     },
+   *   ],
+   * });
+   *
+   * // Wait for the user operation to complete or fail
+   * const result = await smartAccount.waitForUserOperation({
+   *   userOpHash: userOp.userOpHash,
+   * });
+   * ```
+   */
+  waitForUserOperation: (
+    options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
+  ) => Promise<WaitForUserOperationReturnType>;
 };

package/client/evm/evm.ts

@@ -1,14 +1,11 @@
-import { Address, serializeTransaction } from "viem";
+import { Address } from "viem";
 
 import {
   CreateServerAccountOptions,
   GetServerAccountOptions,
   ListServerAccountsOptions,
   CreateSmartAccountOptions,
-  RequestFaucetOptions,
-  SendUserOperationOptions,
   WaitForUserOperationOptions,
-  RequestFaucetResult,
   SignHashOptions,
   SignatureResult,
   SignMessageOptions,
@@ -23,16 +20,24 @@ import {
   GetUserOperationOptions,
   ListSmartAccountResult,
   ListSmartAccountsOptions,
-  ListTokenBalancesOptions,
-  ListTokenBalancesResult,
-  SendTransactionOptions,
-  TransactionResult,
   GetOrCreateServerAccountOptions,
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
+import {
+  listTokenBalances,
+  ListTokenBalancesResult,
+  ListTokenBalancesOptions,
+} from "../../actions/evm/listTokenBalances.js";
+import {
+  RequestFaucetOptions,
+  RequestFaucetResult,
+  requestFaucet,
+} from "../../actions/evm/requestFaucet.js";
+import { sendTransaction } from "../../actions/evm/sendTransaction.js";
 import {
   sendUserOperation,
+  SendUserOperationOptions,
   SendUserOperationReturnType,
 } from "../../actions/evm/sendUserOperation.js";
 import {
@@ -43,6 +48,10 @@ import { APIError } from "../../openapi-client/errors.js";
 import { CdpOpenApiClient } from "../../openapi-client/index.js";
 import { Hex } from "../../types/misc.js";
 
+import type {
+  TransactionResult,
+  SendTransactionOptions,
+} from "../../actions/evm/sendTransaction.js";
 /**
  * The namespace containing all EVM methods.
  */
@@ -376,28 +385,7 @@ export class EvmClient implements EvmClientInterface {
    * }
    */
   async listTokenBalances(options: ListTokenBalancesOptions): Promise<ListTokenBalancesResult> {
-    const response = await CdpOpenApiClient.listEvmTokenBalances(options.network, options.address, {
-      pageSize: options.pageSize,
-      pageToken: options.pageToken,
-    });
-
-    const balances = response.balances.map(balance => {
-      return {
-        token: {
-          network: balance.token.network,
-          contractAddress: balance.token.contractAddress as Address,
-        },
-        amount: {
-          amount: BigInt(balance.amount.amount),
-          decimals: BigInt(balance.amount.decimals),
-        },
-      };
-    });
-
-    return {
-      balances,
-      nextPageToken: response.nextPageToken,
-    };
+    return listTokenBalances(CdpOpenApiClient, options);
   }
 
   /**
@@ -509,14 +497,7 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async requestFaucet(options: RequestFaucetOptions): Promise<RequestFaucetResult> {
-    const { transactionHash } = await CdpOpenApiClient.requestEvmFaucet(
-      { address: options.address, network: options.network, token: options.token },
-      options.idempotencyKey,
-    );
-
-    return {
-      transactionHash: transactionHash as Hex,
-    };
+    return requestFaucet(CdpOpenApiClient, options);
   }
 
   /**
@@ -566,27 +547,7 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async sendTransaction(options: SendTransactionOptions): Promise<TransactionResult> {
-    const { address, network, idempotencyKey } = options;
-    let transaction = options.transaction;
-
-    if (typeof transaction !== "string") {
-      transaction = serializeTransaction({
-        ...transaction,
-        // chainId is ignored in favor of network
-        chainId: 1,
-        type: "eip1559",
-      });
-    }
-
-    const result = await CdpOpenApiClient.sendEvmTransaction(
-      address,
-      { transaction, network },
-      idempotencyKey,
-    );
-
-    return {
-      transactionHash: result.transactionHash as Hex,
-    };
+    return sendTransaction(CdpOpenApiClient, options);
   }
 
   /**
@@ -617,8 +578,11 @@ export class EvmClient implements EvmClientInterface {
    * });
    * ```
    */
-  async sendUserOperation(options: SendUserOperationOptions): Promise<SendUserOperationReturnType> {
-    return sendUserOperation(CdpOpenApiClient, options.smartAccount, {
+  async sendUserOperation(
+    options: SendUserOperationOptions<unknown[]>,
+  ): Promise<SendUserOperationReturnType> {
+    return sendUserOperation(CdpOpenApiClient, {
+      smartAccount: options.smartAccount,
       network: options.network,
       calls: options.calls,
       paymasterUrl: options.paymasterUrl,

package/client/evm/evm.types.ts

@@ -1,20 +1,30 @@
-import {
+import type {
   EvmAccount as Account,
   EvmServerAccount as ServerAccount,
   EvmSmartAccount as SmartAccount,
 } from "../../accounts/types.js";
-import { SendUserOperationReturnType } from "../../actions/evm/sendUserOperation.js";
-import { Actions } from "../../actions/evm/types.js";
-import {
+import type {
+  ListTokenBalancesOptions,
+  ListTokenBalancesResult,
+} from "../../actions/evm/listTokenBalances.js";
+import type { RequestFaucetOptions, RequestFaucetResult } from "../../actions/evm/requestFaucet.js";
+import type {
+  TransactionResult,
+  SendTransactionOptions,
+} from "../../actions/evm/sendTransaction.js";
+import type {
+  SendUserOperationOptions,
+  SendUserOperationReturnType,
+} from "../../actions/evm/sendUserOperation.js";
+import type { Actions } from "../../actions/evm/types.js";
+import type {
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
   OpenApiEvmMethods,
-  ListEvmTokenBalancesNetwork,
-  SendEvmTransactionBodyNetwork,
 } from "../../openapi-client/index.js";
-import { Call, Calls } from "../../types/calls.js";
-import { Address, Hex, TransactionRequestEIP1559 } from "../../types/misc.js";
-import { WaitOptions } from "../../utils/wait.js";
+import type { Calls } from "../../types/calls.js";
+import type { Address, Hex } from "../../types/misc.js";
+import type { WaitOptions } from "../../utils/wait.js";
 
 /**
  * The EvmClient type, where all OpenApiEvmMethods methods are wrapped.
@@ -50,7 +60,9 @@ export type EvmClientInterface = Omit<
   prepareUserOperation: (options: PrepareUserOperationOptions) => Promise<UserOperation>;
   requestFaucet: (options: RequestFaucetOptions) => Promise<RequestFaucetResult>;
   sendTransaction: (options: SendTransactionOptions) => Promise<TransactionResult>;
-  sendUserOperation: (options: SendUserOperationOptions) => Promise<SendUserOperationReturnType>;
+  sendUserOperation: (
+    options: SendUserOperationOptions<unknown[]>,
+  ) => Promise<SendUserOperationReturnType>;
   signHash: (options: SignHashOptions) => Promise<SignatureResult>;
   signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
   signTransaction: (options: SignTransactionOptions) => Promise<SignatureResult>;
@@ -222,67 +234,6 @@ export interface CreateSmartAccountOptions {
   idempotencyKey?: string;
 }
 
-/**
- * Options for requesting funds from an EVM faucet.
- */
-export interface RequestFaucetOptions {
-  /** The address of the account. */
-  address: string;
-  /** The network to request funds from. */
-  network: "base-sepolia" | "ethereum-sepolia";
-  /** The token to request funds for. */
-  token: "eth" | "usdc" | "eurc" | "cbbtc";
-  /** The idempotency key. */
-  idempotencyKey?: string;
-}
-
-/**
- * The result of requesting funds from an EVM faucet.
- */
-export interface RequestFaucetResult {
-  /** The transaction hash. */
-  transactionHash: Hex;
-}
-
-/**
- * Options for sending an EVM transaction.
- */
-export interface SendTransactionOptions {
-  /** The address of the account. */
-  address: Address;
-  /**
-   * The transaction to send. The chainId is ignored in favor of the `network` field.
-   *
-   * This can be either:
-   * - An RLP-encoded transaction to sign and send, as a 0x-prefixed hex string, or
-   * - An EIP-1559 transaction request object.
-   */
-  transaction: Hex | TransactionRequestEIP1559;
-  /**
-   * The network to send the transaction to.
-   * The chainId in the `transaction` field is ignored in favor of this field.
-   */
-  network: SendEvmTransactionBodyNetwork;
-  /** The idempotency key. */
-  idempotencyKey?: string;
-}
-
-/**
- * Options for sending a user operation.
- */
-export interface SendUserOperationOptions {
-  /** The smart account. */
-  smartAccount: SmartAccount;
-  /** The network. */
-  network: EvmUserOperationNetwork;
-  /** The calls. */
-  calls: Call[];
-  /** The paymaster URL. */
-  paymasterUrl?: string;
-  /** The idempotency key. */
-  idempotencyKey?: string;
-}
-
 /**
  * Options for signing an EVM hash.
  */
@@ -327,14 +278,6 @@ export interface SignatureResult {
   signature: Hex;
 }
 
-/**
- * Result of a transaction
- */
-export interface TransactionResult {
-  /** The hash of the transaction. */
-  transactionHash: Hex;
-}
-
 /**
  * Options for waiting for a user operation.
  */
@@ -346,73 +289,3 @@ export interface WaitForUserOperationOptions {
   /** The wait options. */
   waitOptions?: WaitOptions;
 }
-
-/**
- * Options for listing EVM token balances.
- */
-export interface ListTokenBalancesOptions {
-  /** The address of the account. */
-  address: Address;
-  /** The network. */
-  network: ListEvmTokenBalancesNetwork;
-  /** The page size to paginate through the token balances. */
-  pageSize?: number;
-  /** The page token to paginate through the token balances. */
-  pageToken?: string;
-}
-
-/**
- * A token on an EVM network, which is either an ERC-20 or a native token (i.e. ETH).
- */
-export interface EvmToken {
-  /**
-   * The contract address of the token. For Ether, the contract address is 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE
-   * per EIP-7528. For ERC-20 tokens, this is the contract address where the token is deployed.
-   */
-  contractAddress: Address;
-  /** The network the token is on. */
-  network: ListEvmTokenBalancesNetwork;
-  /**
-   * The symbol of the token, which is optional and non-unique. Note: This field
-   * may not be present for most tokens while the API is still under development.
-   */
-  symbol?: string;
-  /**
-   * The name of the token, which is optional and non-unique. Note: This field
-   * may not be present for most tokens while the API is still under development.
-   */
-  name?: string;
-}
-
-/**
- * A token amount on an EVM network.
- */
-export interface EvmTokenAmount {
-  /** The amount of the token in the smallest indivisible unit of the token. */
-  amount: bigint;
-  /** The number of decimals in the token. */
-  decimals: bigint;
-}
-
-/**
- * An EVM token balance.
- */
-export interface EvmTokenBalance {
-  /** The token. */
-  token: EvmToken;
-  /** The amount of the token. */
-  amount: EvmTokenAmount;
-}
-
-/**
- * The result of listing EVM token balances.
- */
-export interface ListTokenBalancesResult {
-  /** The token balances. */
-  balances: EvmTokenBalance[];
-  /**
-   * The next page token to paginate through the token balances.
-   * If undefined, there are no more token balances to paginate through.
-   */
-  nextPageToken?: string;
-}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/version.ts

@@ -1 +1 @@
-export const version = "1.5.0";
+export const version = "1.6.0";