@coinbase/cdp-sdk 1.29.0 → 1.30.0

package/_types/spend-permissions/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../spend-permissions/constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,gCAAgC,+CAA+C,CAAC;AAE7F,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAssB/B,CAAC"}

package/_types/spend-permissions/types.d.ts

@@ -0,0 +1,30 @@
+import type { Address, Hex } from "../types/misc.js";
+/**
+ * A spend permission structure that defines authorization for spending tokens
+ */
+export type SpendPermission = {
+    /** The account address that owns the tokens */
+    account: Address;
+    /** The address that is authorized to spend the tokens */
+    spender: Address;
+    /** The token contract address (use 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE for ETH) */
+    token: Address;
+    /** The maximum amount that can be spent (in wei for ETH, or token's smallest unit) */
+    allowance: bigint;
+    /** Time period in seconds for the spending allowance */
+    period: number;
+    /** Start timestamp for when the permission becomes valid */
+    start: number;
+    /** End timestamp for when the permission expires */
+    end: number;
+    /** Unique salt to prevent replay attacks */
+    salt: bigint;
+    /** Additional data for the permission */
+    extraData: Hex;
+};
+/**
+ * Networks that the SpendPermissionManager contract supports.
+ * From https://github.com/coinbase/spend-permissions/blob/main/README.md#deployments
+ */
+export type SpendPermissionNetworks = "base" | "base-sepolia" | "ethereum" | "ethereum-sepolia" | "optimism" | "optimism-sepolia" | "arbitrum" | "avalanche" | "binance" | "polygon" | "zora";
+//# sourceMappingURL=types.d.ts.map

package/_types/spend-permissions/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../spend-permissions/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAC;AAErD;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,+CAA+C;IAC/C,OAAO,EAAE,OAAO,CAAC;IACjB,yDAAyD;IACzD,OAAO,EAAE,OAAO,CAAC;IACjB,0FAA0F;IAC1F,KAAK,EAAE,OAAO,CAAC;IACf,sFAAsF;IACtF,SAAS,EAAE,MAAM,CAAC;IAClB,wDAAwD;IACxD,MAAM,EAAE,MAAM,CAAC;IACf,4DAA4D;IAC5D,KAAK,EAAE,MAAM,CAAC;IACd,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IACZ,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,yCAAyC;IACzC,SAAS,EAAE,GAAG,CAAC;CAChB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAC/B,MAAM,GACN,cAAc,GACd,UAAU,GACV,kBAAkB,GAClB,UAAU,GACV,kBAAkB,GAClB,UAAU,GACV,WAAW,GACX,SAAS,GACT,SAAS,GACT,MAAM,CAAC"}

package/_types/version.d.ts

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

package/accounts/evm/networkCapabilities.ts

@@ -18,6 +18,7 @@ export const NETWORK_CAPABILITIES = {
     sendTransaction: true,
     quoteSwap: true,
     swap: true,
+    useSpendPermission: true,
   },
   "base-sepolia": {
     listTokenBalances: true,
@@ -29,6 +30,7 @@ export const NETWORK_CAPABILITIES = {
     sendTransaction: true,
     quoteSwap: false,
     swap: false,
+    useSpendPermission: true,
   },
   ethereum: {
     listTokenBalances: true,
@@ -40,6 +42,7 @@ export const NETWORK_CAPABILITIES = {
     sendTransaction: true,
     quoteSwap: true,
     swap: true,
+    useSpendPermission: true,
   },
   "ethereum-sepolia": {
     listTokenBalances: false,
@@ -51,6 +54,7 @@ export const NETWORK_CAPABILITIES = {
     sendTransaction: true,
     quoteSwap: false,
     swap: false,
+    useSpendPermission: true,
   },
   "ethereum-hoodi": {
     listTokenBalances: false,
@@ -62,6 +66,103 @@ export const NETWORK_CAPABILITIES = {
     sendTransaction: true, // Always available (uses wallet client for non-base networks)
     quoteSwap: false,
     swap: false,
+    useSpendPermission: false,
+  },
+  optimism: {
+    listTokenBalances: false,
+    requestFaucet: false,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  "optimism-sepolia": {
+    listTokenBalances: false,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  arbitrum: {
+    listTokenBalances: false,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  "arbitrum-sepolia": {
+    listTokenBalances: false,
+    requestFaucet: true,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  avalanche: {
+    listTokenBalances: false,
+    requestFaucet: false,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  binance: {
+    listTokenBalances: false,
+    requestFaucet: false,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  polygon: {
+    listTokenBalances: false,
+    requestFaucet: false,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
+  },
+  zora: {
+    listTokenBalances: false,
+    requestFaucet: false,
+    quoteFund: false,
+    fund: false,
+    waitForFundOperationReceipt: false,
+    transfer: false,
+    sendTransaction: true, // Always available (uses wallet client for non-base networks)
+    quoteSwap: false,
+    swap: false,
+    useSpendPermission: true,
   },
 } as const;
 

package/accounts/evm/toEvmServerAccount.ts

@@ -21,6 +21,8 @@ import {
   type RequestFaucetResult,
 } from "../../actions/evm/requestFaucet.js";
 import { sendTransaction } from "../../actions/evm/sendTransaction.js";
+import { useSpendPermission } from "../../actions/evm/spend-permissions/account.use.js";
+import { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapTransaction } from "../../actions/evm/swap/sendSwapTransaction.js";
 import { accountTransferStrategy } from "../../actions/evm/transfer/accountTransferStrategy.js";
@@ -256,6 +258,19 @@ export function toEvmServerAccount(
         taker: this.address, // Always use account's address as taker
       });
     },
+    async __experimental_useSpendPermission(
+      options: UseSpendPermissionOptions,
+    ): Promise<TransactionResult> {
+      Analytics.trackAction({
+        action: "use_spend_permission",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
+      return useSpendPermission(apiClient, this.address, options);
+    },
     name: options.account.name,
     type: "evm-server",
     policies: options.account.policies,

package/accounts/evm/toEvmSmartAccount.ts

@@ -19,6 +19,8 @@ import {
   sendUserOperation,
 } from "../../actions/evm/sendUserOperation.js";
 import { signAndWrapTypedDataForSmartAccount } from "../../actions/evm/signAndWrapTypedDataForSmartAccount.js";
+import { useSpendPermission } from "../../actions/evm/spend-permissions/smartAccount.use.js";
+import { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
 import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
@@ -41,6 +43,10 @@ import {
   SignTypedDataOptions,
   UserOperation,
 } from "../../client/evm/evm.types.js";
+import {
+  type CdpOpenApiClientType,
+  type EvmSmartAccount as EvmSmartAccountModel,
+} from "../../openapi-client/index.js";
 
 import type { EvmAccount, EvmSmartAccount, KnownEvmNetworks } from "./types.js";
 import type {
@@ -49,10 +55,6 @@ import type {
   SmartAccountSwapOptions,
   SmartAccountSwapResult,
 } from "../../actions/evm/swap/types.js";
-import type {
-  CdpOpenApiClientType,
-  EvmSmartAccount as EvmSmartAccountModel,
-} from "../../openapi-client/index.js";
 import type { Address, Hex } from "../../types/misc.js";
 
 /**
@@ -258,6 +260,19 @@ export function toEvmSmartAccount(
       });
       return result.signature;
     },
+    async __experimental_useSpendPermission(
+      options: UseSpendPermissionOptions,
+    ): Promise<SendUserOperationReturnType> {
+      Analytics.trackAction({
+        action: "use_spend_permission",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
+      return useSpendPermission(apiClient, account, options);
+    },
 
     name: options.smartAccount.name,
     type: "evm-smart",

package/accounts/evm/toNetworkScopedEvmServerAccount.ts

@@ -16,6 +16,7 @@ import type {
   SendTransactionOptions,
   TransactionResult,
 } from "../../actions/evm/sendTransaction.js";
+import type { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import type { AccountQuoteSwapOptions, AccountSwapOptions } from "../../actions/evm/swap/types.js";
 import type { TransferOptions } from "../../actions/evm/transfer/types.js";
 import type { WaitForFundOperationOptions } from "../../actions/waitForFundOperationReceipt.js";
@@ -23,6 +24,7 @@ import type {
   ListEvmTokenBalancesNetwork,
   SendEvmTransactionBodyNetwork,
 } from "../../openapi-client/index.js";
+import type { SpendPermissionNetworks } from "../../spend-permissions/types.js";
 import type { Address, TransactionRequestEIP1559 } from "../../types/misc.js";
 
 /**
@@ -193,5 +195,18 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
+  if (isMethodSupportedOnNetwork("useSpendPermission", resolvedNetworkName)) {
+    Object.assign(account, {
+      __experimental_useSpendPermission: async (
+        spendPermissionOptions: Omit<UseSpendPermissionOptions, "network">,
+      ) => {
+        return options.account.__experimental_useSpendPermission({
+          ...spendPermissionOptions,
+          network: options.network as SpendPermissionNetworks,
+        });
+      },
+    });
+  }
+
   return account;
 }

package/accounts/evm/toNetworkScopedEvmSmartAccount.ts

@@ -6,6 +6,7 @@ import { getUserOperation } from "../../actions/evm/getUserOperation.js";
 import { listTokenBalances } from "../../actions/evm/listTokenBalances.js";
 import { requestFaucet } from "../../actions/evm/requestFaucet.js";
 import { sendUserOperation } from "../../actions/evm/sendUserOperation.js";
+import { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
 import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
@@ -39,6 +40,7 @@ import type {
   EvmUserOperationNetwork,
   ListEvmTokenBalancesNetwork,
 } from "../../openapi-client/index.js";
+import type { SpendPermissionNetworks } from "../../spend-permissions/types.js";
 
 /**
  * Options for converting a pre-existing EvmSmartAccount and owner to a NetworkScopedEvmSmartAccount
@@ -279,5 +281,18 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
     });
   }
 
+  if (isMethodSupportedOnNetwork("useSpendPermission", options.network)) {
+    Object.assign(account, {
+      __experimental_useSpendPermission: async (
+        spendPermissionOptions: Omit<UseSpendPermissionOptions, "network">,
+      ) => {
+        return options.smartAccount.__experimental_useSpendPermission({
+          ...spendPermissionOptions,
+          network: options.network as SpendPermissionNetworks,
+        });
+      },
+    });
+  }
+
   return account;
 }

package/accounts/evm/types.ts

@@ -19,6 +19,7 @@ import {
   SendUserOperationOptions,
   SendUserOperationReturnType,
 } from "../../actions/evm/sendUserOperation.js";
+import { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import {
   AccountQuoteSwapOptions,
   AccountQuoteSwapResult,
@@ -39,6 +40,7 @@ import {
   WaitForFundOperationResult,
 } from "../../actions/waitForFundOperationReceipt.js";
 import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { SpendPermissionNetworks } from "../../spend-permissions/types.js";
 
 import type {
   SmartAccountTransferOptions,
@@ -242,6 +244,14 @@ export type NetworkSpecificSmartAccountActions<Network extends string> = Prettif
             options: DistributedOmit<SmartAccountSwapOptions, "network">,
           ) => Promise<SmartAccountSwapResult>;
         }
+      : EmptyObject) &
+    // Conditionally include useSpendPermission
+    (Network extends SpendPermissionNetworks
+      ? {
+          __experimental_useSpendPermission: (
+            options: Omit<UseSpendPermissionOptions, "network">,
+          ) => Promise<SendUserOperationReturnType>;
+        }
       : EmptyObject)
 >;
 
@@ -322,6 +332,14 @@ export type NetworkSpecificAccountActions<Network extends string> = Prettify<
       ? {
           swap: (options: AccountSwapOptions) => Promise<AccountSwapResult>;
         }
+      : EmptyObject) &
+    // Conditionally include useSpendPermission
+    (Network extends SpendPermissionNetworks
+      ? {
+          __experimental_useSpendPermission: (
+            options: Omit<UseSpendPermissionOptions, "network">,
+          ) => Promise<TransactionResult>;
+        }
       : EmptyObject)
 >;
 

package/accounts/solana/toSolanaAccount.ts

@@ -3,8 +3,9 @@ import { SolanaQuote } from "../../actions/Quote.js";
 import { SolanaFundOptions, fund } from "../../actions/solana/fund/fund.js";
 import { SolanaQuoteFundOptions, quoteFund } from "../../actions/solana/fund/quoteFund.js";
 import { requestFaucet } from "../../actions/solana/requestFaucet.js";
+import { sendTransaction, SendTransactionResult } from "../../actions/solana/sendTransaction.js";
 import { signMessage } from "../../actions/solana/signMessage.js";
-import { signTransaction } from "../../actions/solana/signTransaction.js";
+import { signTransaction, SignTransactionResult } from "../../actions/solana/signTransaction.js";
 import { transfer, type TransferOptions } from "../../actions/solana/transfer.js";
 import { FundOperationResult } from "../../actions/types.js";
 import {
@@ -15,6 +16,7 @@ import {
 import { Analytics } from "../../analytics.js";
 import {
   RequestFaucetOptions,
+  SendTransactionOptions,
   SignatureResult,
   SignMessageOptions,
   SignTransactionOptions,
@@ -44,6 +46,7 @@ export function toSolanaAccount(
   const account: SolanaAccount = {
     address: options.account.address,
     name: options.account.name,
+    policies: options.account.policies,
     async requestFaucet(options: Omit<RequestFaucetOptions, "address">): Promise<SignatureResult> {
       Analytics.trackAction({
         action: "request_faucet",
@@ -68,7 +71,7 @@ export function toSolanaAccount(
     },
     async signTransaction(
       options: Omit<SignTransactionOptions, "address">,
-    ): Promise<SignatureResult> {
+    ): Promise<SignTransactionResult> {
       Analytics.trackAction({
         action: "sign_transaction",
         accountType: "solana",
@@ -79,7 +82,18 @@ export function toSolanaAccount(
         address: account.address,
       });
     },
-    policies: options.account.policies,
+    async sendTransaction(
+      options: Omit<SendTransactionOptions, "address">,
+    ): Promise<SendTransactionResult> {
+      Analytics.trackAction({
+        action: "send_transaction",
+        accountType: "solana",
+      });
+
+      return sendTransaction(apiClient, {
+        ...options,
+      });
+    },
     async transfer(options: Omit<TransferOptions, "from">): Promise<SignatureResult> {
       Analytics.trackAction({
         action: "transfer",

package/actions/evm/getUserOperation.ts

@@ -39,5 +39,6 @@ export async function getUserOperation(
     status: userOp.status,
     transactionHash: userOp.transactionHash as Hex | undefined,
     userOpHash: userOp.userOpHash as Hex,
+    receipts: userOp.receipts,
   };
 }

package/actions/evm/spend-permissions/account.use.ts

@@ -0,0 +1,48 @@
+import { encodeFunctionData } from "viem";
+
+import {
+  SPEND_PERMISSION_MANAGER_ABI,
+  SPEND_PERMISSION_MANAGER_ADDRESS,
+} from "../../../spend-permissions/constants.js";
+import { serializeEIP1559Transaction } from "../../../utils/serializeTransaction.js";
+
+import type { UseSpendPermissionOptions } from "./types.js";
+import type {
+  CdpOpenApiClientType,
+  SendEvmTransactionBodyNetwork,
+} from "../../../openapi-client/index.js";
+import type { Address, Hex } from "../../../types/misc.js";
+import type { TransactionResult } from "../sendTransaction.js";
+
+/**
+ * Use a spend permission to spend tokens.
+ *
+ * @param apiClient - The API client to use.
+ * @param address - The address of the account to use the spend permission on.
+ * @param options - The options for the spend permission.
+ *
+ * @returns The transaction hash of the spend permission.
+ */
+export async function useSpendPermission(
+  apiClient: CdpOpenApiClientType,
+  address: Address,
+  options: UseSpendPermissionOptions,
+): Promise<TransactionResult> {
+  const { spendPermission, value, network } = options;
+
+  const result = await apiClient.sendEvmTransaction(address, {
+    transaction: serializeEIP1559Transaction({
+      to: SPEND_PERMISSION_MANAGER_ADDRESS,
+      data: encodeFunctionData({
+        abi: SPEND_PERMISSION_MANAGER_ABI,
+        functionName: "spend",
+        args: [spendPermission, value],
+      }),
+    }),
+    network: network as SendEvmTransactionBodyNetwork,
+  });
+
+  return {
+    transactionHash: result.transactionHash as Hex,
+  };
+}

package/actions/evm/spend-permissions/smartAccount.use.ts

@@ -0,0 +1,49 @@
+import { encodeFunctionData } from "viem";
+
+import {
+  SPEND_PERMISSION_MANAGER_ABI,
+  SPEND_PERMISSION_MANAGER_ADDRESS,
+} from "../../../spend-permissions/constants.js";
+import { type SendUserOperationReturnType, sendUserOperation } from "../sendUserOperation.js";
+
+import type { UseSpendPermissionOptions } from "./types.js";
+import type { EvmSmartAccount } from "../../../accounts/evm/types.js";
+import type {
+  CdpOpenApiClientType,
+  EvmUserOperationNetwork,
+} from "../../../openapi-client/index.js";
+
+/**
+ * Use a spend permission to spend tokens.
+ *
+ * @param apiClient - The API client to use.
+ * @param account - The smart account to use.
+ * @param options - The options for the spend permission.
+ *
+ * @returns The result of the spend permission.
+ */
+export function useSpendPermission(
+  apiClient: CdpOpenApiClientType,
+  account: EvmSmartAccount,
+  options: UseSpendPermissionOptions,
+): Promise<SendUserOperationReturnType> {
+  const { spendPermission, value, network } = options;
+
+  const data = encodeFunctionData({
+    abi: SPEND_PERMISSION_MANAGER_ABI,
+    functionName: "spend",
+    args: [spendPermission, value],
+  });
+
+  return sendUserOperation(apiClient, {
+    smartAccount: account,
+    network: network as EvmUserOperationNetwork,
+    calls: [
+      {
+        to: SPEND_PERMISSION_MANAGER_ADDRESS,
+        data,
+        value: 0n,
+      },
+    ],
+  });
+}

package/actions/evm/spend-permissions/types.ts

@@ -0,0 +1,13 @@
+import type { SpendPermission, SpendPermissionNetworks } from "../../../spend-permissions/types.js";
+
+/**
+ * Options for using a spend permission
+ */
+export type UseSpendPermissionOptions = {
+  /** The spend permission to use */
+  spendPermission: SpendPermission;
+  /** The amount to spend (must be <= allowance) */
+  value: bigint;
+  /** The network to execute the transaction on */
+  network: SpendPermissionNetworks;
+};

package/actions/evm/types.ts

@@ -14,6 +14,7 @@ import {
 } from "../../client/evm/evm.types.js";
 import { Hex } from "../../types/misc.js";
 import { EvmQuote } from "../Quote.js";
+import { UseSpendPermissionOptions } from "./spend-permissions/types.js";
 
 import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
 import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
@@ -353,6 +354,46 @@ export type AccountActions = Actions & {
    * ```
    */
   swap: (options: AccountSwapOptions) => Promise<AccountSwapResult>;
+
+  /**
+   * @deprecated Experimental! This method name will change, and is subject to other breaking changes.
+   *
+   * Uses a spend permission to execute a transaction.
+   * This allows the account to spend tokens that have been approved via a spend permission.
+   *
+   * @param {UseSpendPermissionOptions} options - Configuration options for using the spend permission.
+   * @param {SpendPermission} options.spendPermission - The spend permission object containing authorization details.
+   * @param {bigint} options.value - The amount to spend (must not exceed the permission's allowance).
+   * @param {KnownEvmNetworks} options.network - The network to execute the transaction on.
+   *
+   * @returns A promise that resolves to the transaction result.
+   *
+   * @throws {Error} If the network doesn't support spend permissions via CDP API.
+   *
+   * @example
+   * ```typescript
+   * const spendPermission = {
+   *   account: "0x1234...", // Smart account that owns the tokens
+   *   spender: account.address, // This account that can spend
+   *   token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
+   *   allowance: parseEther("0.01"),
+   *   period: 86400, // 1 day
+   *   start: 0,
+   *   end: 281474976710655,
+   *   salt: 0n,
+   *   extraData: "0x",
+   * };
+   *
+   * const result = await account.__experimental_useSpendPermission({
+   *   spendPermission,
+   *   value: parseEther("0.001"), // Spend 0.001 ETH
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  __experimental_useSpendPermission: (
+    options: UseSpendPermissionOptions,
+  ) => Promise<TransactionResult>;
 };
 
 export type SmartAccountActions = Actions & {
@@ -640,4 +681,44 @@ export type SmartAccountActions = Actions & {
   signTypedData: (
     options: Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks },
   ) => Promise<Hex>;
+
+  /**
+   * @deprecated Experimental! This method name will change, and is subject to other breaking changes.
+   *
+   * Uses a spend permission to execute a transaction via user operation.
+   * This allows the smart account to spend tokens that have been approved via a spend permission.
+   *
+   * @param {UseSpendPermissionOptions} options - Configuration options for using the spend permission.
+   * @param {SpendPermission} options.spendPermission - The spend permission object containing authorization details.
+   * @param {bigint} options.value - The amount to spend (must not exceed the permission's allowance).
+   * @param {KnownEvmNetworks} options.network - The network to execute the transaction on.
+   *
+   * @returns A promise that resolves to the user operation result.
+   *
+   * @throws {Error} If the network doesn't support spend permissions via CDP API.
+   *
+   * @example
+   * ```typescript
+   * const spendPermission = {
+   *   account: "0x1234...", // Smart account that owns the tokens
+   *   spender: smartAccount.address, // This smart account that can spend
+   *   token: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE", // ETH
+   *   allowance: parseEther("0.01"),
+   *   period: 86400, // 1 day
+   *   start: 0,
+   *   end: 281474976710655,
+   *   salt: 0n,
+   *   extraData: "0x",
+   * };
+   *
+   * const result = await smartAccount.__experimental_useSpendPermission({
+   *   spendPermission,
+   *   value: parseEther("0.001"), // Spend 0.001 ETH
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  __experimental_useSpendPermission: (
+    options: UseSpendPermissionOptions,
+  ) => Promise<SendUserOperationReturnType>;
 };