@coinbase/cdp-sdk 1.6.0 → 1.7.0

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.
  */
@@ -15,7 +25,7 @@ export type Network = SendEvmTransactionBodyNetwork | EvmUserOperationNetwork;
 /**
  * The options for the transfer.
  */
-export type TransferOptions = {
+type TransferOptions = {
   /** The account to transfer the token to. */
   to: EvmAccount | Address;
   /**
@@ -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>;
 }

package/actions/evm/types.ts

@@ -1,14 +1,21 @@
-import { SendUserOperationReturnType, SendUserOperationOptions } from "./sendUserOperation.js";
+import { SendUserOperationOptions, SendUserOperationReturnType } from "./sendUserOperation.js";
+import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { EvmAccount, EvmSmartAccount } from "../../openapi-client/index.js";
 
-import type { ListTokenBalancesResult, ListTokenBalancesOptions } from "./listTokenBalances.js";
+import type { ListTokenBalancesOptions, ListTokenBalancesResult } 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 {
+  AccountTransferOptions,
+  SmartAccountTransferOptions,
+  TransferResult,
+} from "./transfer/types.js";
 import type {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "./waitForUserOperation.js";
-export type Actions = {
+
+type Actions<T extends EvmAccount | EvmSmartAccount> = {
   /**
    * Transfer an amount of a token from an account to another account.
    *
@@ -92,7 +99,9 @@ export type Actions = {
    * });
    * ```
    */
-  transfer: (options: TransferOptions) => Promise<TransferResult>;
+  transfer: (
+    options: T extends EvmSmartAccount ? SmartAccountTransferOptions : AccountTransferOptions,
+  ) => Promise<TransferResult>;
 
   /**
    * List the token balances of an account.
@@ -132,7 +141,9 @@ export type Actions = {
    * ```
    */
   requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
+};
 
+export type AccountActions = Actions<EvmAccount> & {
   /**
    * Signs an EVM transaction and sends it to the specified network using the Coinbase API.
    * This method handles nonce management and gas estimation automatically.
@@ -178,7 +189,9 @@ export type Actions = {
    * ```
    */
   sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<TransactionResult>;
+};
 
+export type SmartAccountActions = Actions<EvmSmartAccount> & {
   /**
    * Sends a user operation.
    *
@@ -241,4 +254,23 @@ export type Actions = {
   waitForUserOperation: (
     options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
   ) => Promise<WaitForUserOperationReturnType>;
+
+  /**
+   * Gets a user operation by its hash.
+   *
+   * @param {GetUserOperationOptions} options - Parameters for getting 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 smartAccount.getUserOperation({
+   *   userOpHash: "0x1234567890123456789012345678901234567890",
+   * });
+   * ```
+   */
+  getUserOperation: (
+    options: Omit<GetUserOperationOptions, "smartAccount">,
+  ) => Promise<UserOperation>;
 };

package/actions/solana/requestFaucet.ts

@@ -0,0 +1,35 @@
+import { RequestFaucetOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Requests funds from a Solana faucet.
+ *
+ * @param apiClient - The API client.
+ * @param {RequestFaucetOptions} options - Parameters for requesting funds from the Solana faucet.
+ * @param {string} options.address - The address to request funds for.
+ * @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 signature.
+ *
+ * @example
+ *          ```ts
+ *          const signature = await requestFaucet(cdp.solana, {
+ *            address: "1234567890123456789012345678901234567890",
+ *            token: "sol",
+ *          });
+ *          ```
+ */
+export async function requestFaucet(
+  apiClient: CdpOpenApiClientType,
+  options: RequestFaucetOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.requestSolanaFaucet(
+    { address: options.address, token: options.token },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.transactionSignature,
+  };
+}

package/actions/solana/signMessage.ts

@@ -0,0 +1,36 @@
+import { SignMessageOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Sign a message.
+ *
+ * @param apiClient - The API client.
+ * @param {SignMessageOptions} options - Parameters for signing the message.
+ * @param {string} options.address - The address to sign the message for.
+ * @param {string} options.message - The message to sign.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the transaction signature.
+ *
+ * @example
+ *          ```ts
+ *          const signature = await signMessage(cdp.solana, {
+ *            address: "1234567890123456789012345678901234567890",
+ *            message: "Hello, world!",
+ *          });
+ *          ```
+ */
+export async function signMessage(
+  apiClient: CdpOpenApiClientType,
+  options: SignMessageOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.signSolanaMessage(
+    options.address,
+    { message: options.message },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.signature,
+  };
+}

package/actions/solana/signTransaction.ts

@@ -0,0 +1,53 @@
+import { SignTransactionOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Signs a transaction.
+ *
+ * @param apiClient - The API client.
+ * @param {SignTransactionOptions} options - Parameters for signing the transaction.
+ * @param {string} options.address - The address to sign the transaction for.
+ * @param {string} options.transaction - The transaction to sign.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the signature.
+ *
+ * @example
+ * ```ts
+ * // Create a Solana account
+ * const account = await cdp.solana.createAccount();
+ *
+ * // Add your transaction instructions here
+ * const transaction = new Transaction()
+ *
+ * // Make sure to set requireAllSignatures to false, since signing will be done through the API
+ * const serializedTransaction = transaction.serialize({
+ *   requireAllSignatures: false,
+ * });
+ *
+ * // Base64 encode the serialized transaction
+ * const transaction = Buffer.from(serializedTransaction).toString("base64");
+ *
+ * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+ * const signature = await signTransaction(cdp.solana, {
+ *   address: account.address,
+ *   transaction,
+ * });
+ * ```
+ */
+export async function signTransaction(
+  apiClient: CdpOpenApiClientType,
+  options: SignTransactionOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.signSolanaTransaction(
+    options.address,
+    {
+      transaction: options.transaction,
+    },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.signedTransaction,
+  };
+}

package/actions/solana/types.ts

@@ -0,0 +1,87 @@
+import {
+  RequestFaucetOptions,
+  SignatureResult,
+  SignMessageOptions,
+  SignTransactionOptions,
+} from "../../client/solana/solana.types.js";
+
+export type AccountActions = {
+  /**
+   * Requests funds from a Solana faucet.
+   *
+   * @param {RequestFaucetOptions} options - Parameters for requesting funds from the Solana faucet.
+   * @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
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Request funds from the Solana faucet
+   * const result = await account.requestFaucet({
+   *   token: "sol",
+   * });
+   * ```
+   */
+  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
+
+  /**
+   * Signs a message.
+   *
+   * @param {SignMessageOptions} options - Parameters for signing the message.
+   * @param {string} options.address - The address to sign the message for.
+   * @param {string} options.message - The message to sign.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Sign a message
+   * const { signature } = await account.signMessage({
+   *   message: "Hello, world!",
+   * });
+   * ```
+   */
+  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
+
+  /**
+   * Signs a transaction.
+   *
+   * @param {SignTransactionOptions} options - Parameters for signing the transaction.
+   * @param {string} options.address - The address to sign the transaction for.
+   * @param {string} options.transaction - The transaction to sign.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Add your transaction instructions here
+   * const transaction = new Transaction()
+   *
+   * // Make sure to set requireAllSignatures to false, since signing will be done through the API
+   * const serializedTransaction = transaction.serialize({
+   *   requireAllSignatures: false,
+   * });
+   *
+   * // Base64 encode the serialized transaction
+   * const transaction = Buffer.from(serializedTransaction).toString("base64");
+   *
+   * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+   * const { signature } = await account.signTransaction({
+   *   transaction,
+   * });
+   * ```
+   */
+  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignatureResult>;
+};

package/client/evm/evm.ts

@@ -24,6 +24,7 @@ import {
 } from "./evm.types.js";
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
+import { getUserOperation } from "../../actions/evm/getUserOperation.js";
 import {
   listTokenBalances,
   ListTokenBalancesResult,
@@ -52,6 +53,7 @@ import type {
   TransactionResult,
   SendTransactionOptions,
 } from "../../actions/evm/sendTransaction.js";
+
 /**
  * The namespace containing all EVM methods.
  */
@@ -292,22 +294,7 @@ export class EvmClient implements EvmClientInterface {
    * ```
    */
   async getUserOperation(options: GetUserOperationOptions): Promise<UserOperation> {
-    const userOp = await CdpOpenApiClient.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,
-    };
+    return getUserOperation(CdpOpenApiClient, options);
   }
 
   /**

package/client/evm/evm.types.ts

@@ -2,7 +2,7 @@ import type {
   EvmAccount as Account,
   EvmServerAccount as ServerAccount,
   EvmSmartAccount as SmartAccount,
-} from "../../accounts/types.js";
+} from "../../accounts/evm/types.js";
 import type {
   ListTokenBalancesOptions,
   ListTokenBalancesResult,
@@ -16,7 +16,7 @@ import type {
   SendUserOperationOptions,
   SendUserOperationReturnType,
 } from "../../actions/evm/sendUserOperation.js";
-import type { Actions } from "../../actions/evm/types.js";
+import type { SmartAccountActions } from "../../actions/evm/types.js";
 import type {
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
@@ -181,7 +181,8 @@ export interface ListServerAccountsOptions {
 /**
  * A smart account that only contains the owner address.
  */
-export interface ReadonlySmartAccount extends Omit<SmartAccount, "owners" | keyof Actions> {
+export interface ReadonlySmartAccount
+  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions> {
   /** The owners of the smart account. */
   owners: Address[];
 }