@coinbase/cdp-sdk 1.28.0 → 1.30.0

package/actions/solana/fund/fund.ts

@@ -0,0 +1,71 @@
+import { formatUnits } from "viem";
+
+import { UserInputValidationError } from "../../../errors.js";
+import {
+  CreatePaymentTransferQuoteBodySourceType,
+  CreatePaymentTransferQuoteBodyTargetType,
+  type CdpOpenApiClientType,
+} from "../../../openapi-client/index.js";
+import { BaseFundOptions, FundOperationResult } from "../../types.js";
+
+/**
+ * Options for funding a Solana account.
+ */
+export interface SolanaFundOptions extends BaseFundOptions {
+  /** The token to request funds for. */
+  token: "sol" | "usdc";
+}
+
+/**
+ * Funds a Solana account.
+ *
+ * @param apiClient - The API client.
+ * @param options - The options for funding a Solana account.
+ *
+ * @returns A promise that resolves to the fund operation result.
+ */
+export async function fund(
+  apiClient: CdpOpenApiClientType,
+  options: SolanaFundOptions,
+): Promise<FundOperationResult> {
+  if (options.token !== "sol" && options.token !== "usdc") {
+    throw new UserInputValidationError("Invalid token, must be sol or usdc");
+  }
+
+  const decimals = options.token === "sol" ? 9 : 6;
+  const amount = formatUnits(options.amount, decimals);
+
+  const paymentMethods = await apiClient.getPaymentMethods();
+  const cardPaymentMethod = paymentMethods.find(
+    method => method.type === "card" && method.actions.includes("source"),
+  );
+
+  if (!cardPaymentMethod) {
+    throw new Error("No card found to fund account");
+  }
+
+  const response = await apiClient.createPaymentTransferQuote({
+    sourceType: CreatePaymentTransferQuoteBodySourceType.payment_method,
+    source: {
+      id: cardPaymentMethod.id,
+    },
+    targetType: CreatePaymentTransferQuoteBodyTargetType.crypto_rail,
+    target: {
+      currency: options.token,
+      network: "solana",
+      address: options.address,
+    },
+    amount,
+    currency: options.token,
+    execute: true,
+  });
+
+  return {
+    id: response.transfer.id,
+    network: response.transfer.target.network,
+    status: response.transfer.status,
+    targetAmount: response.transfer.targetAmount,
+    targetCurrency: response.transfer.targetCurrency,
+    transactionHash: response.transfer.transactionHash,
+  };
+}

package/actions/solana/fund/quoteFund.ts

@@ -0,0 +1,77 @@
+import { formatUnits } from "viem";
+
+import { UserInputValidationError } from "../../../errors.js";
+import {
+  CdpOpenApiClientType,
+  CreatePaymentTransferQuoteBodySourceType,
+  CreatePaymentTransferQuoteBodyTargetType,
+} from "../../../openapi-client/index.js";
+import { SolanaQuote } from "../../Quote.js";
+import { BaseQuoteFundOptions } from "../../types.js";
+
+/**
+ * Options for getting a quote to fund a Solana account.
+ */
+export interface SolanaQuoteFundOptions extends BaseQuoteFundOptions {
+  /** The token to request funds for. */
+  token: "sol" | "usdc";
+}
+
+/**
+ * Gets a quote to fund a Solana account.
+ *
+ * @param apiClient - The API client.
+ * @param options - The options for getting a quote to fund a Solana account.
+ *
+ * @returns A promise that resolves to the quote.
+ */
+export async function quoteFund(
+  apiClient: CdpOpenApiClientType,
+  options: SolanaQuoteFundOptions,
+): Promise<SolanaQuote> {
+  if (options.token !== "sol" && options.token !== "usdc") {
+    throw new UserInputValidationError("Invalid token, must be sol or usdc");
+  }
+
+  const decimals = options.token === "sol" ? 9 : 6;
+  const amount = formatUnits(options.amount, decimals);
+
+  const paymentMethods = await apiClient.getPaymentMethods();
+  const cardPaymentMethod = paymentMethods.find(
+    method => method.type === "card" && method.actions.includes("source"),
+  );
+
+  if (!cardPaymentMethod) {
+    throw new Error("No card found to fund account");
+  }
+
+  const response = await apiClient.createPaymentTransferQuote({
+    sourceType: CreatePaymentTransferQuoteBodySourceType.payment_method,
+    source: {
+      id: cardPaymentMethod.id,
+    },
+    targetType: CreatePaymentTransferQuoteBodyTargetType.crypto_rail,
+    target: {
+      currency: options.token,
+      network: "solana",
+      address: options.address,
+    },
+    amount,
+    currency: options.token,
+  });
+
+  return new SolanaQuote(
+    apiClient,
+    response.transfer.id,
+    "solana",
+    response.transfer.sourceAmount,
+    response.transfer.sourceCurrency,
+    response.transfer.targetAmount,
+    response.transfer.targetCurrency,
+    response.transfer.fees.map(fee => ({
+      type: fee.type,
+      amount: fee.amount,
+      currency: fee.currency,
+    })),
+  );
+}

package/actions/solana/sendTransaction.ts

@@ -1,6 +1,13 @@
-import { SendTransactionOptions, TransactionResult } from "../../client/solana/solana.types.js";
+import { SendTransactionOptions } from "../../client/solana/solana.types.js";
 import { CdpOpenApiClientType } from "../../openapi-client/index.js";
 
+export interface SendTransactionResult {
+  /** The signature of the transaction base58 encoded. */
+  transactionSignature: string;
+  /** @deprecated Use transactionSignature instead. */
+  signature: string;
+}
+
 /**
  * Sends a Solana transaction using the Coinbase API.
  *
@@ -23,7 +30,7 @@ import { CdpOpenApiClientType } from "../../openapi-client/index.js";
 export async function sendTransaction(
   apiClient: CdpOpenApiClientType,
   options: SendTransactionOptions,
-): Promise<TransactionResult> {
+): Promise<SendTransactionResult> {
   const signature = await apiClient.sendSolanaTransaction(
     {
       network: options.network,
@@ -33,6 +40,7 @@ export async function sendTransaction(
   );
 
   return {
+    transactionSignature: signature.transactionSignature,
     signature: signature.transactionSignature,
   };
 }

package/actions/solana/signTransaction.ts

@@ -1,6 +1,13 @@
-import { SignTransactionOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { SignTransactionOptions } from "../../client/solana/solana.types.js";
 import { CdpOpenApiClientType } from "../../openapi-client/index.js";
 
+export interface SignTransactionResult {
+  /** The signature of the transaction base58 encoded. */
+  signedTransaction: string;
+  /** @deprecated Use signedTransaction instead. */
+  signature: string;
+}
+
 /**
  * Signs a transaction.
  *
@@ -38,7 +45,7 @@ import { CdpOpenApiClientType } from "../../openapi-client/index.js";
 export async function signTransaction(
   apiClient: CdpOpenApiClientType,
   options: SignTransactionOptions,
-): Promise<SignatureResult> {
+): Promise<SignTransactionResult> {
   const signature = await apiClient.signSolanaTransaction(
     options.address,
     {
@@ -48,6 +55,7 @@ export async function signTransaction(
   );
 
   return {
+    signedTransaction: signature.signedTransaction,
     signature: signature.signedTransaction,
   };
 }

package/actions/solana/types.ts

@@ -1,10 +1,22 @@
 import { TransferOptions } from "./transfer.js";
 import {
   RequestFaucetOptions,
+  SendTransactionOptions,
   SignatureResult,
   SignMessageOptions,
   SignTransactionOptions,
 } from "../../client/solana/solana.types.js";
+import { SolanaQuote } from "../Quote.js";
+import { FundOperationResult } from "../types.js";
+import {
+  WaitForFundOperationOptions,
+  WaitForFundOperationResult,
+} from "../waitForFundOperationReceipt.js";
+import { SolanaFundOptions } from "./fund/fund.js";
+import { SolanaQuoteFundOptions } from "./fund/quoteFund.js";
+import { SendTransactionResult } from "./sendTransaction.js";
+
+import type { SignTransactionResult } from "./signTransaction.js";
 
 export type AccountActions = {
   /**
@@ -79,12 +91,50 @@ export type AccountActions = {
    * 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({
+   * const { signedTransaction } = await account.signTransaction({
+   *   transaction,
+   * });
+   * ```
+   */
+  signTransaction: (
+    options: Omit<SignTransactionOptions, "address">,
+  ) => Promise<SignTransactionResult>;
+
+  /**
+   * Sends a transaction.
+   *
+   * @param {SendTransactionOptions} options - Parameters for sending the transaction.
+   * @param {string} options.address - The address to send the transaction for.
+   * @param {string} options.transaction - The transaction to send.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the transaction 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 { transactionSignature } = await account.sendTransaction({
    *   transaction,
    * });
    * ```
    */
-  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignatureResult>;
+  sendTransaction: (
+    options: Omit<SendTransactionOptions, "address">,
+  ) => Promise<SendTransactionResult>;
 
   /**
    * Transfers SOL or SPL tokens between accounts
@@ -112,4 +162,65 @@ export type AccountActions = {
    * ```
    */
   transfer: (options: Omit<TransferOptions, "from">) => Promise<SignatureResult>;
+
+  /**
+   * Gets a quote to fund a Solana account.
+   *
+   * @param options - The options for the quote fund.
+   * @param options.token - The token to fund the account with.
+   * @param options.amount - The amount of the token to fund represented as an atomic unit.
+   * It's common to use `parseUnits` utils from viem to convert to atomic units.
+   * Otherwise, you can pass atomic units directly.
+   *
+   * @returns A promise that resolves to a Quote object containing details about the funding operation.
+   *
+   * @example
+   * ```ts
+   * const quote = await account.quoteFund({
+   *   token: "usdc",
+   *   amount: 1000000n,
+   * });
+   * ```
+   */
+  quoteFund: (options: Omit<SolanaQuoteFundOptions, "address">) => Promise<SolanaQuote>;
+
+  /**
+   * Funds a Solana account with the specified token amount.
+   *
+   * @param options - The options for the fund operation.
+   * @param options.token - The token to fund the account with (e.g., 'usdc').
+   * @param options.amount - The amount of the token to fund represented as an atomic unit.
+   * It's common to use `parseUnits` utils from viem to convert to atomic units.
+   * Otherwise, you can pass atomic units directly.
+   *
+   * @returns A promise that resolves to the fund operation result containing the transfer details.
+   *
+   * @example
+   * ```ts
+   * const fundOperation = await account.fund({
+   *   token: "usdc",
+   *   amount: 1000000n,
+   * });
+   * ```
+   */
+  fund: (options: Omit<SolanaFundOptions, "address">) => Promise<FundOperationResult>;
+
+  /**
+   * Waits for a fund operation to complete and returns the transfer receipt.
+   *
+   * @param options - The options for the wait for fund operation.
+   * @param options.transferId - The ID of the transfer to wait for.
+   *
+   * @returns A promise that resolves to the completed transfer receipt containing details about the funding operation.
+   *
+   * @example
+   * ```ts
+   * const completedTransfer = await account.waitForFundOperationReceipt({
+   *   transferId: "transfer_123",
+   * });
+   * ```
+   */
+  waitForFundOperationReceipt(
+    options: WaitForFundOperationOptions,
+  ): Promise<WaitForFundOperationResult>;
 };

package/actions/types.ts

@@ -0,0 +1,39 @@
+import { TransferStatus } from "../openapi-client/index.js";
+
+/**
+ * Base options for getting a quote to fund an account.
+ */
+export interface BaseQuoteFundOptions {
+  /** The address of the account. */
+  address: string;
+  /** The amount to fund the account with, in atomic units (e.g. wei for ETH, lamports for SOL) of the token. */
+  amount: bigint;
+}
+
+/**
+ * Base options for funding an account.
+ */
+export interface BaseFundOptions {
+  /** The address of the account. */
+  address: string;
+  /** The amount to fund the account with, in atomic units (e.g. wei for ETH, lamports for SOL) of the token. */
+  amount: bigint;
+}
+
+/**
+ * The result of a fund operation.
+ */
+export type FundOperationResult = {
+  /** The transfer that was created to fund the account. */
+  id: string;
+  /** The network that the transfer was created on. */
+  network: string;
+  /** The target amount that will be received. */
+  targetAmount: string;
+  /** The currency that will be received. */
+  targetCurrency: string;
+  /** The status of the fund operation. */
+  status: TransferStatus;
+  /** The transaction hash of the transfer. */
+  transactionHash?: string;
+};

package/actions/{evm/fund/waitForFundOperationReceipt.ts → waitForFundOperationReceipt.ts}

@@ -1,5 +1,5 @@
-import { CdpOpenApiClientType, Transfer, TransferStatus } from "../../../openapi-client/index.js";
-import { wait, WaitOptions } from "../../../utils/wait.js";
+import { CdpOpenApiClientType, Transfer, TransferStatus } from "../openapi-client/index.js";
+import { wait, WaitOptions } from "../utils/wait.js";
 
 /**
  * Options for waiting for a fund operation.

package/auth/hooks/axios/withAuth.ts

@@ -84,6 +84,7 @@ export function withAuth(axiosClient: AxiosInstance, options: AuthInterceptorOpt
     });
 
     if (options.debug) {
+      // eslint-disable-next-line no-console
       console.log("Request:", {
         method,
         url: fullyQualifiedURL,
@@ -98,6 +99,7 @@ export function withAuth(axiosClient: AxiosInstance, options: AuthInterceptorOpt
   if (options.debug) {
     axiosClient.interceptors.response.use(
       response => {
+        // eslint-disable-next-line no-console
         console.log("Response:", {
           status: response.status,
           statusText: response.statusText,
@@ -117,6 +119,7 @@ export function withAuth(axiosClient: AxiosInstance, options: AuthInterceptorOpt
           cause: error.cause,
         };
 
+        // eslint-disable-next-line no-console
         console.error("Response Error:", errorDetails);
         return Promise.reject(error);
       },

package/auth/utils/http.ts

@@ -126,7 +126,8 @@ export async function getAuthHeaders(
  */
 function requiresWalletAuth(requestMethod: string, requestPath: string): boolean {
   return (
-    requestPath?.includes("/accounts") && (requestMethod === "POST" || requestMethod === "DELETE")
+    (requestPath?.includes("/accounts") || requestPath?.includes("/spend-permissions")) &&
+    (requestMethod === "POST" || requestMethod === "DELETE" || requestMethod === "PUT")
   );
 }
 

package/client/evm/evm.ts

@@ -5,6 +5,7 @@ import { type Address, getTypesForEIP712Domain } from "viem";
 import {
   CreateServerAccountOptions,
   CreateSmartAccountOptions,
+  CreateSpendPermissionOptions,
   CreateSwapQuoteOptions,
   CreateSwapQuoteResult,
   EvmClientInterface,
@@ -68,6 +69,7 @@ import {
   CdpOpenApiClient,
   EIP712Message as OpenAPIEIP712Message,
 } from "../../openapi-client/index.js";
+import { SPEND_PERMISSION_MANAGER_ADDRESS } from "../../spend-permissions/constants.js";
 import { Hex } from "../../types/misc.js";
 import { decryptWithPrivateKey, generateExportEncryptionKeyPair } from "../../utils/export.js";
 
@@ -341,9 +343,15 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_smart",
     });
 
+    const owners = [options.owner.address];
+
+    if (options.__experimental_enableSpendPermission) {
+      owners.push(SPEND_PERMISSION_MANAGER_ADDRESS);
+    }
+
     const openApiSmartAccount = await CdpOpenApiClient.createEvmSmartAccount(
       {
-        owners: [options.owner.address],
+        owners: owners,
         name: options.name,
       },
       options.idempotencyKey,
@@ -359,6 +367,58 @@ export class EvmClient implements EvmClientInterface {
     return smartAccount;
   }
 
+  /**
+   * Creates a spend permission for a smart account.
+   *
+   * @param {CreateSpendPermissionOptions} options - Parameters for creating the spend permission.
+   * @param {SpendPermission} options.spendPermission - The spend permission to create.
+   * @param {string} [options.idempotencyKey] - The idempotency key to use for the spend permission.
+   *
+   * @returns A promise that resolves to the spend permission.
+   *
+   * @example
+   * ```ts
+   * const userOperation = await cdp.evm.createSpendPermission({
+   *   spendPermission,
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  async createSpendPermission(options: CreateSpendPermissionOptions): Promise<UserOperation> {
+    Analytics.trackAction({
+      action: "create_spend_permission",
+    });
+
+    const userOperation = await CdpOpenApiClient.createSpendPermission(
+      options.spendPermission.account,
+      {
+        account: options.spendPermission.account,
+        spender: options.spendPermission.spender,
+        token: options.spendPermission.token,
+        allowance: options.spendPermission.allowance.toString(),
+        period: options.spendPermission.period.toString(),
+        start: options.spendPermission.start.toString(),
+        end: options.spendPermission.end.toString(),
+        salt: options.spendPermission.salt.toString(),
+        extraData: options.spendPermission.extraData,
+        network: options.network,
+        paymasterUrl: options.paymasterUrl,
+      },
+      options.idempotencyKey,
+    );
+
+    return {
+      network: userOperation.network,
+      userOpHash: userOperation.userOpHash as Hex,
+      status: userOperation.status,
+      calls: userOperation.calls.map(call => ({
+        to: call.to as Address,
+        value: BigInt(call.value),
+        data: call.data as Hex,
+      })),
+    };
+  }
+
   /**
    * Gets a CDP EVM account.
    *

package/client/evm/evm.types.ts

@@ -1,3 +1,5 @@
+import { SpendPermission } from "../../spend-permissions/types.js";
+
 import type {
   EvmAccount as Account,
   EvmServerAccount as ServerAccount,
@@ -24,6 +26,7 @@ import type {
   OpenApiEvmMethods,
   UpdateEvmAccountBody as UpdateEvmAccount,
   UpdateEvmSmartAccountBody as UpdateEvmSmartAccount,
+  UserOperationReceipt,
 } from "../../openapi-client/index.js";
 import type { Calls } from "../../types/calls.js";
 import type { Address, EIP712Message, Hex } from "../../types/misc.js";
@@ -36,6 +39,7 @@ export type EvmClientInterface = Omit<
   typeof OpenApiEvmMethods,
   | "createEvmAccount" // mapped to createAccount
   | "createEvmSmartAccount" // mapped to createSmartAccount
+  | "createSpendPermission" // mapped to createSpendPermission
   | "importEvmAccount" // mapped to importAccount
   | "exportEvmAccount" // mapped to exportAccount
   | "exportEvmAccountByName" // mapped to exportAccount
@@ -256,6 +260,17 @@ export interface CreateSwapQuoteResult {
   execute: (options?: ExecuteSwapQuoteOptions) => Promise<ExecuteSwapQuoteResult>;
 }
 
+export interface CreateSpendPermissionOptions {
+  /** The spend permission. */
+  spendPermission: SpendPermission;
+  /** The network. */
+  network: EvmUserOperationNetwork;
+  /** The paymaster URL. */
+  paymasterUrl?: string;
+  /** The idempotency key. */
+  idempotencyKey?: string;
+}
+
 /**
  * Options for getting a user operation.
  */
@@ -314,6 +329,10 @@ export interface UserOperation {
    * The hash of the transaction that included this particular user operation. This gets set after the user operation is broadcasted and the transaction is included in a block.
    */
   transactionHash?: Hex;
+  /**
+   * The receipts associated with the broadcasted user operation.
+   */
+  receipts?: UserOperationReceipt[];
 }
 
 /**
@@ -392,6 +411,12 @@ export interface GetOrCreateSmartAccountOptions {
   name: string;
   /** The owner of the account. */
   owner: Account;
+  /**
+   * @deprecated Experimental! This method name will change, and is subject to other breaking changes.
+   *
+   * The flag to enable spend permission.
+   */
+  __experimental_enableSpendPermission?: boolean;
 }
 
 /**
@@ -487,6 +512,12 @@ export interface CreateSmartAccountOptions {
   idempotencyKey?: string;
   /** The name of the account. */
   name?: string;
+  /**
+   * @deprecated Experimental! This method name will change, and is subject to other breaking changes.
+   *
+   * The flag to enable spend permission.
+   */
+  __experimental_enableSpendPermission?: boolean;
 }
 
 /**

package/client/solana/solana.ts

@@ -18,15 +18,20 @@ import {
   SignMessageOptions,
   SignTransactionOptions,
   SolanaClientInterface,
-  TransactionResult,
   UpdateSolanaAccountOptions,
 } from "./solana.types.js";
 import { toSolanaAccount } from "../../accounts/solana/toSolanaAccount.js";
 import { SolanaAccount } from "../../accounts/solana/types.js";
 import { requestFaucet } from "../../actions/solana/requestFaucet.js";
-import { sendTransaction } from "../../actions/solana/sendTransaction.js";
+import {
+  sendTransaction,
+  type SendTransactionResult,
+} from "../../actions/solana/sendTransaction.js";
 import { signMessage } from "../../actions/solana/signMessage.js";
-import { signTransaction } from "../../actions/solana/signTransaction.js";
+import {
+  signTransaction,
+  type SignTransactionResult,
+} from "../../actions/solana/signTransaction.js";
 import { Analytics } from "../../analytics.js";
 import { ImportAccountPublicRSAKey } from "../../constants.js";
 import { UserInputValidationError } from "../../errors.js";
@@ -485,7 +490,7 @@ export class SolanaClient implements SolanaClientInterface {
    * });
    * ```
    */
-  async signTransaction(options: SignTransactionOptions): Promise<SignatureResult> {
+  async signTransaction(options: SignTransactionOptions): Promise<SignTransactionResult> {
     Analytics.trackAction({
       action: "sign_transaction",
       accountType: "solana",
@@ -574,7 +579,7 @@ export class SolanaClient implements SolanaClientInterface {
    * });
    * ```
    */
-  async sendTransaction(options: SendTransactionOptions): Promise<TransactionResult> {
+  async sendTransaction(options: SendTransactionOptions): Promise<SendTransactionResult> {
     Analytics.trackAction({
       action: "send_transaction",
       accountType: "solana",

package/index.ts

@@ -8,5 +8,10 @@ export {
   type UpdatePolicyBody,
 } from "./policies/schema.js";
 export { NetworkError } from "./openapi-client/errors.js";
+export type { SpendPermission } from "./spend-permissions/types.js";
+export {
+  SPEND_PERMISSION_MANAGER_ABI as spendPermissionManagerAbi,
+  SPEND_PERMISSION_MANAGER_ADDRESS as spendPermissionManagerAddress,
+} from "./spend-permissions/constants.js";
 
-export { parseEther } from "viem";
+export { parseEther, parseUnits } from "viem";