Add Subscription Revoke Functionality (#169)

* Add subscription revoke functionality

* Apply formatting

* Add explanation to ts-expect-error

* share logic

* format

* individual files for utils

* fix typecheck

Author: spencerstock

packages/account-sdk/src/interface/payment/base.browser.ts

@@ -3,6 +3,7 @@ import { getPaymentStatus } from './getPaymentStatus.js';
 import { getSubscriptionStatus } from './getSubscriptionStatus.js';
 import { pay } from './pay.js';
 import { prepareCharge } from './prepareCharge.js';
+import { prepareRevoke } from './prepareRevoke.js';
 import { subscribe } from './subscribe.js';
 import type {
   PaymentOptions,
@@ -11,6 +12,8 @@ import type {
   PaymentStatusOptions,
   PrepareChargeOptions,
   PrepareChargeResult,
+  PrepareRevokeOptions,
+  PrepareRevokeResult,
   SubscriptionOptions,
   SubscriptionResult,
   SubscriptionStatus,
@@ -28,6 +31,7 @@ export const base = {
     subscribe,
     getStatus: getSubscriptionStatus,
     prepareCharge,
+    prepareRevoke,
   },
   constants: {
     CHAIN_IDS,
@@ -40,6 +44,8 @@ export const base = {
     PaymentStatus: PaymentStatus;
     PrepareChargeOptions: PrepareChargeOptions;
     PrepareChargeResult: PrepareChargeResult;
+    PrepareRevokeOptions: PrepareRevokeOptions;
+    PrepareRevokeResult: PrepareRevokeResult;
     SubscriptionOptions: SubscriptionOptions;
     SubscriptionResult: SubscriptionResult;
     SubscriptionStatus: SubscriptionStatus;

packages/account-sdk/src/interface/payment/base.node.ts

@@ -5,6 +5,8 @@ import { getPaymentStatus } from './getPaymentStatus.js';
 import { getSubscriptionStatus } from './getSubscriptionStatus.js';
 import { pay } from './pay.js';
 import { prepareCharge } from './prepareCharge.js';
+import { prepareRevoke } from './prepareRevoke.js';
+import { revoke } from './revoke.js';
 import { subscribe } from './subscribe.js';
 import type {
   ChargeOptions,
@@ -17,6 +19,10 @@ import type {
   PaymentStatusOptions,
   PrepareChargeOptions,
   PrepareChargeResult,
+  PrepareRevokeOptions,
+  PrepareRevokeResult,
+  RevokeOptions,
+  RevokeResult,
   SubscriptionOptions,
   SubscriptionResult,
   SubscriptionStatus,
@@ -35,6 +41,8 @@ export const base = {
     getStatus: getSubscriptionStatus,
     prepareCharge,
     charge,
+    prepareRevoke,
+    revoke,
     getOrCreateSubscriptionOwnerWallet,
   },
   constants: {
@@ -50,6 +58,10 @@ export const base = {
     PrepareChargeResult: PrepareChargeResult;
     ChargeOptions: ChargeOptions;
     ChargeResult: ChargeResult;
+    PrepareRevokeOptions: PrepareRevokeOptions;
+    PrepareRevokeResult: PrepareRevokeResult;
+    RevokeOptions: RevokeOptions;
+    RevokeResult: RevokeResult;
     SubscriptionOptions: SubscriptionOptions;
     SubscriptionResult: SubscriptionResult;
     SubscriptionStatus: SubscriptionStatus;

packages/account-sdk/src/interface/payment/charge.ts

@@ -1,7 +1,9 @@
-import { CdpClient } from '@coinbase/cdp-sdk';
 import { type Address } from 'viem';
 import { prepareCharge } from './prepareCharge.js';
 import type { ChargeOptions, ChargeResult } from './types.js';
+import { createCdpClientOrThrow } from './utils/createCdpClientOrThrow.js';
+import { getExistingSmartWalletOrThrow } from './utils/getExistingSmartWalletOrThrow.js';
+import { sendUserOpAndWait } from './utils/sendUserOpAndWait.js';
 
 /**
  * Prepares and executes a charge for a given spend permission.
@@ -14,7 +16,7 @@ import type { ChargeOptions, ChargeResult } from './types.js';
  *
  * The function will:
  * - Use the provided CDP credentials or fall back to environment variables
- * - Create or retrieve a smart wallet to act as the subscription owner
+ * - Get the existing smart wallet that acts as the subscription owner
  * - Prepare the charge call data using the subscription ID
  * - Execute the charge transaction using the smart wallet
  * - Optionally use a paymaster for transaction sponsorship
@@ -86,53 +88,15 @@ export async function charge(options: ChargeOptions): Promise<ChargeResult> {
   } = options;
 
   // Step 1: Initialize CDP client with provided credentials or environment variables
-  let cdpClient: CdpClient;
-
-  try {
-    cdpClient = new CdpClient({
-      apiKeyId: cdpApiKeyId,
-      apiKeySecret: cdpApiKeySecret,
-      walletSecret: cdpWalletSecret,
-    });
-  } catch (error) {
-    // Re-throw with more context about what credentials are missing
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(
-      `Failed to initialize CDP client for subscription charge. ${errorMessage}\n\nPlease ensure you have set the required CDP credentials either:\n1. As environment variables: CDP_API_KEY_ID, CDP_API_KEY_SECRET, CDP_WALLET_SECRET\n2. As function parameters: cdpApiKeyId, cdpApiKeySecret, cdpWalletSecret\n\nYou can get these credentials from https://portal.cdp.coinbase.com/`
-    );
-  }
+  const cdpClient = createCdpClientOrThrow(
+    { cdpApiKeyId, cdpApiKeySecret, cdpWalletSecret },
+    'subscription charge'
+  );
 
   // Step 2: Get the existing EVM account and smart wallet
   // NOTE: We use get() instead of getOrCreate() to ensure the wallet already exists.
   // The wallet should have been created prior to executing a charge on it.
-  let smartWallet;
-  try {
-    // First get the existing EOA that owns the smart wallet
-    const eoaAccount = await cdpClient.evm.getAccount({ name: walletName });
-
-    if (!eoaAccount) {
-      throw new Error(
-        `EOA wallet "${walletName}" not found. The wallet must be created before executing a charge. Use getOrCreateSubscriptionOwnerWallet() to create the wallet first.`
-      );
-    }
-
-    // Get the existing smart wallet with the EOA as owner
-    // NOTE: Both the EOA wallet and smart wallet are given the same name intentionally.
-    // This simplifies wallet management and ensures consistency across the system.
-    smartWallet = await cdpClient.evm.getSmartAccount({
-      name: walletName, // Same name as the EOA wallet
-      owner: eoaAccount,
-    });
-
-    if (!smartWallet) {
-      throw new Error(
-        `Smart wallet "${walletName}" not found. The wallet must be created before executing a charge. Use getOrCreateSubscriptionOwnerWallet() to create the wallet first.`
-      );
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to get charge smart wallet "${walletName}": ${errorMessage}`);
-  }
+  const smartWallet = await getExistingSmartWalletOrThrow(cdpClient, walletName, 'charge');
 
   // Step 3: Prepare the charge call data (including optional recipient transfer)
   const chargeCalls = await prepareCharge({ id, amount, testnet, recipient });
@@ -143,49 +107,15 @@ export async function charge(options: ChargeOptions): Promise<ChargeResult> {
 
   // Step 5: Execute the charge transaction(s) using the smart wallet
   // Smart wallets can batch multiple calls and use paymasters for gas sponsorship
-  let transactionHash: string | undefined;
-
-  try {
-    // Build the calls array for the smart wallet
-    const calls = chargeCalls.map((call) => ({
-      to: call.to,
-      data: call.data,
-      value: call.value,
-    }));
-
-    // For smart wallets, we can send all calls in a single user operation
-    // This is more efficient and allows for better paymaster integration
-
-    // Send the user operation
-    const userOpResult = await networkSmartWallet.sendUserOperation({
-      calls,
-      ...(paymasterUrl && { paymasterUrl }),
-    });
-
-    // The sendUserOperation returns { smartAccountAddress, status: "broadcast", userOpHash }
-    // We need to wait for the operation to complete to get the transaction hash
-    const completedOp = await networkSmartWallet.waitForUserOperation({
-      userOpHash: userOpResult.userOpHash,
-      waitOptions: {
-        timeoutSeconds: 60, // Wait up to 60 seconds for the operation to complete
-      },
-    });
-
-    // Check if the operation was successful
-    if (completedOp.status === 'failed') {
-      throw new Error(`User operation failed: ${userOpResult.userOpHash}`);
-    }
-
-    // For completed operations, we have the transaction hash
-    transactionHash = completedOp.transactionHash;
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    throw new Error(`Failed to execute charge transaction with smart wallet: ${errorMessage}`);
-  }
-
-  if (!transactionHash) {
-    throw new Error('No transaction hash received from charge execution');
-  }
+  // For smart wallets, we can send all calls in a single user operation
+  // This is more efficient and allows for better paymaster integration
+  const transactionHash = await sendUserOpAndWait(
+    networkSmartWallet,
+    chargeCalls,
+    paymasterUrl,
+    60, // Wait up to 60 seconds for the operation to complete
+    'charge'
+  );
 
   // Return success result
   return {

packages/account-sdk/src/interface/payment/index.node.ts

@@ -9,6 +9,8 @@ export { getPaymentStatus } from './getPaymentStatus.js';
 export { getSubscriptionStatus } from './getSubscriptionStatus.js';
 export { pay } from './pay.js';
 export { prepareCharge } from './prepareCharge.js';
+export { prepareRevoke } from './prepareRevoke.js';
+export { revoke } from './revoke.js';
 export { subscribe } from './subscribe.js';
 
 // Export types
@@ -29,6 +31,11 @@ export type {
   PrepareChargeCall,
   PrepareChargeOptions,
   PrepareChargeResult,
+  PrepareRevokeCall,
+  PrepareRevokeOptions,
+  PrepareRevokeResult,
+  RevokeOptions,
+  RevokeResult,
   SubscriptionOptions,
   SubscriptionResult,
   SubscriptionStatus,

packages/account-sdk/src/interface/payment/index.ts

@@ -4,6 +4,7 @@ export { getPaymentStatus } from './getPaymentStatus.js';
 export { getSubscriptionStatus } from './getSubscriptionStatus.js';
 export { pay } from './pay.js';
 export { prepareCharge } from './prepareCharge.js';
+export { prepareRevoke } from './prepareRevoke.js';
 export { subscribe } from './subscribe.js';
 export type {
   ChargeOptions,
@@ -22,6 +23,11 @@ export type {
   PrepareChargeCall,
   PrepareChargeOptions,
   PrepareChargeResult,
+  PrepareRevokeCall,
+  PrepareRevokeOptions,
+  PrepareRevokeResult,
+  RevokeOptions,
+  RevokeResult,
   SubscriptionOptions,
   SubscriptionResult,
   SubscriptionStatus,

packages/account-sdk/src/interface/payment/prepareCharge.ts

@@ -3,8 +3,9 @@ import {
   fetchPermission,
   prepareSpendCallData,
 } from '../public-utilities/spend-permission/index.js';
-import { CHAIN_IDS, TOKENS } from './constants.js';
+import { TOKENS } from './constants.js';
 import type { PrepareChargeOptions, PrepareChargeResult } from './types.js';
+import { validateUSDCBasePermission } from './utils/validateUSDCBasePermission.js';
 
 /**
  * Prepares call data for charging a subscription.
@@ -76,36 +77,7 @@ export async function prepareCharge(options: PrepareChargeOptions): Promise<Prep
   }
 
   // Validate this is a USDC permission on the correct network
-  const expectedChainId = testnet ? CHAIN_IDS.baseSepolia : CHAIN_IDS.base;
-  const expectedTokenAddress = testnet
-    ? TOKENS.USDC.addresses.baseSepolia.toLowerCase()
-    : TOKENS.USDC.addresses.base.toLowerCase();
-
-  if (permission.chainId !== expectedChainId) {
-    // Determine if the subscription is on mainnet or testnet
-    const isSubscriptionOnMainnet = permission.chainId === CHAIN_IDS.base;
-    const isSubscriptionOnTestnet = permission.chainId === CHAIN_IDS.baseSepolia;
-
-    let errorMessage: string;
-    if (testnet && isSubscriptionOnMainnet) {
-      errorMessage =
-        'The subscription was requested on testnet but is actually a mainnet subscription';
-    } else if (!testnet && isSubscriptionOnTestnet) {
-      errorMessage =
-        'The subscription was requested on mainnet but is actually a testnet subscription';
-    } else {
-      // Fallback for unexpected chain IDs
-      errorMessage = `Subscription is on chain ${permission.chainId}, expected ${expectedChainId} (${testnet ? 'Base Sepolia' : 'Base'})`;
-    }
-
-    throw new Error(errorMessage);
-  }
-
-  if (permission.permission.token.toLowerCase() !== expectedTokenAddress) {
-    throw new Error(
-      `Subscription is not for USDC token. Got ${permission.permission.token}, expected ${expectedTokenAddress}`
-    );
-  }
+  validateUSDCBasePermission(permission, testnet);
 
   // Determine the amount to pass to prepareSpendCallData
   let spendAmount: bigint | 'max-remaining-allowance';

packages/account-sdk/src/interface/payment/prepareRevoke.ts

@@ -0,0 +1,65 @@
+import {
+  fetchPermission,
+  prepareRevokeCallData,
+} from '../public-utilities/spend-permission/index.js';
+import type { PrepareRevokeOptions, PrepareRevokeResult } from './types.js';
+import { validateUSDCBasePermission } from './utils/validateUSDCBasePermission.js';
+
+/**
+ * Prepares call data for revoking a subscription.
+ *
+ * This function fetches the subscription (spend permission) details using its ID (permission hash)
+ * and prepares the necessary call data to revoke the subscription. It wraps the lower-level
+ * prepareRevokeCallData function with subscription-specific logic.
+ *
+ * The resulting call data includes the encoded transaction to revoke the spend permission.
+ *
+ * @param options - Options for preparing the revoke
+ * @param options.id - The subscription ID (permission hash) returned from subscribe()
+ * @param options.testnet - Whether this permission is on testnet (Base Sepolia). Defaults to false (mainnet)
+ * @returns Promise<PrepareRevokeResult> - Call data for the revoke
+ * @throws Error if the subscription cannot be found
+ *
+ * @example
+ * ```typescript
+ * import { base } from '@base-org/account/payment';
+ *
+ * // Prepare to revoke a subscription
+ * const revokeCall = await base.subscription.prepareRevoke({
+ *   id: '0x71319cd488f8e4f24687711ec5c95d9e0c1bacbf5c1064942937eba4c7cf2984',
+ *   testnet: false
+ * });
+ *
+ * // Send the call using your app's subscription owner account
+ * await provider.request({
+ *   method: 'wallet_sendCalls',
+ *   params: [{
+ *     version: '2.0.0',
+ *     from: subscriptionOwner, // Must be the spender/subscription owner!
+ *     chainId: testnet ? '0x14a34' : '0x2105',
+ *     calls: [revokeCall],
+ *   }],
+ * });
+ * ```
+ */
+export async function prepareRevoke(options: PrepareRevokeOptions): Promise<PrepareRevokeResult> {
+  const { id, testnet = false } = options;
+
+  // Fetch the permission using the subscription ID (permission hash)
+  const permission = await fetchPermission({
+    permissionHash: id,
+  });
+
+  // If no permission found, throw an error
+  if (!permission) {
+    throw new Error(`Subscription with ID ${id} not found`);
+  }
+
+  // Validate this is a USDC permission on the correct network
+  validateUSDCBasePermission(permission, testnet);
+
+  // Call the existing prepareRevokeCallData utility
+  const callData = await prepareRevokeCallData(permission);
+
+  return callData;
+}