@coinbase/cdp-sdk 1.31.0 → 1.32.0

package/client/evm/evm.ts

@@ -6,6 +6,7 @@ import {
   CreateServerAccountOptions,
   CreateSmartAccountOptions,
   CreateSpendPermissionOptions,
+  RevokeSpendPermissionOptions,
   CreateSwapQuoteOptions,
   CreateSwapQuoteResult,
   EvmClientInterface,
@@ -22,6 +23,7 @@ import {
   ListServerAccountsOptions,
   ListSmartAccountResult,
   ListSmartAccountsOptions,
+  ListSpendPermissionsOptions,
   PrepareUserOperationOptions,
   ServerAccount,
   SignatureResult,
@@ -39,6 +41,7 @@ import {
 import { toEvmServerAccount } from "../../accounts/evm/toEvmServerAccount.js";
 import { toEvmSmartAccount } from "../../accounts/evm/toEvmSmartAccount.js";
 import { getUserOperation } from "../../actions/evm/getUserOperation.js";
+import { listSpendPermissions } from "../../actions/evm/listSpendPermissions.js";
 import {
   listTokenBalances,
   ListTokenBalancesOptions,
@@ -67,6 +70,7 @@ import { UserInputValidationError } from "../../errors.js";
 import { APIError } from "../../openapi-client/errors.js";
 import {
   CdpOpenApiClient,
+  ListSpendPermissionsResult,
   EIP712Message as OpenAPIEIP712Message,
 } from "../../openapi-client/index.js";
 import { SPEND_PERMISSION_MANAGER_ADDRESS } from "../../spend-permissions/constants.js";
@@ -122,21 +126,7 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    const openApiAccount = await CdpOpenApiClient.createEvmAccount(
-      {
-        name: options.name,
-        accountPolicy: options.accountPolicy,
-      },
-      options.idempotencyKey,
-    );
-
-    const account = toEvmServerAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
-    return account;
+    return this._createAccountInternal(options);
   }
 
   /**
@@ -343,28 +333,7 @@ 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: owners,
-        name: options.name,
-      },
-      options.idempotencyKey,
-    );
-
-    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
-      smartAccount: openApiSmartAccount,
-      owner: options.owner,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
-
-    return smartAccount;
+    return this._createSmartAccountInternal(options);
   }
 
   /**
@@ -419,6 +388,53 @@ export class EvmClient implements EvmClientInterface {
     };
   }
 
+  /**
+   * Revokes a spend permission for a smart account.
+   *
+   * @param {RevokeSpendPermissionOptions} options - Parameters for revoking the spend permission.
+   * @param {string} options.address - The address of the smart account.
+   * @param {string} options.permissionHash - The hash of the spend permission to revoke.
+   * @param {string} options.network - The network of the spend permission.
+   * @param {string} [options.paymasterUrl] - The paymaster URL of the spend permission.
+   *
+   * @returns A promise that resolves to the user operation.
+   *
+   * @example
+   * ```ts
+   * const userOperation = await cdp.evm.revokeSpendPermission({
+   *   address: "0x1234567890123456789012345678901234567890",
+   *   permissionHash: "0x1234567890123456789012345678901234567890123456789012345678901234",
+   *   network: "base-sepolia",
+   * });
+   * ```
+   */
+  async revokeSpendPermission(options: RevokeSpendPermissionOptions): Promise<UserOperation> {
+    Analytics.trackAction({
+      action: "revoke_spend_permission",
+    });
+
+    const userOperation = await CdpOpenApiClient.revokeSpendPermission(
+      options.address,
+      {
+        network: options.network,
+        permissionHash: options.permissionHash,
+        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.
    *
@@ -450,25 +466,7 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    const openApiAccount = await (() => {
-      if (options.address) {
-        return CdpOpenApiClient.getEvmAccount(options.address);
-      }
-
-      if (options.name) {
-        return CdpOpenApiClient.getEvmAccountByName(options.name);
-      }
-
-      throw new UserInputValidationError("Either address or name must be provided");
-    })();
-
-    const account = toEvmServerAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
-    return account;
+    return this._getAccountInternal(options);
   }
 
   /**
@@ -498,23 +496,7 @@ export class EvmClient implements EvmClientInterface {
       action: "get_smart_account",
     });
 
-    const openApiSmartAccount = await (async () => {
-      if (options.address) {
-        return CdpOpenApiClient.getEvmSmartAccount(options.address);
-      } else if (options.name) {
-        return CdpOpenApiClient.getEvmSmartAccountByName(options.name);
-      }
-      throw new UserInputValidationError("Either address or name must be provided");
-    })();
-
-    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
-      smartAccount: openApiSmartAccount,
-      owner: options.owner,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
-
-    return smartAccount;
+    return this._getSmartAccountInternal(options);
   }
 
   /**
@@ -539,20 +521,20 @@ export class EvmClient implements EvmClientInterface {
     });
 
     try {
-      const account = await this.getAccount(options);
+      const account = await this._getAccountInternal(options);
       return account;
     } catch (error) {
       // If it failed because the account doesn't exist, create it
       const doesAccountNotExist = error instanceof APIError && error.statusCode === 404;
       if (doesAccountNotExist) {
         try {
-          const account = await this.createAccount(options);
+          const account = await this._createAccountInternal(options);
           return account;
         } catch (error) {
-          // If it failed because the account already exists, throw an error
+          // If it failed because the account already exists, get the existing account
           const doesAccountAlreadyExist = error instanceof APIError && error.statusCode === 409;
           if (doesAccountAlreadyExist) {
-            const account = await this.getAccount(options);
+            const account = await this._getAccountInternal(options);
             return account;
           }
           throw error;
@@ -588,20 +570,20 @@ export class EvmClient implements EvmClientInterface {
     });
 
     try {
-      const account = await this.getSmartAccount(options);
+      const account = await this._getSmartAccountInternal(options);
       return account;
     } catch (error) {
       // If it failed because the account doesn't exist, create it
       const doesAccountNotExist = error instanceof APIError && error.statusCode === 404;
       if (doesAccountNotExist) {
         try {
-          const account = await this.createSmartAccount(options);
+          const account = await this._createSmartAccountInternal(options);
           return account;
         } catch (error) {
-          // If it failed because the account already exists, throw an error
+          // If it failed because the account already exists, get the existing account
           const doesAccountAlreadyExist = error instanceof APIError && error.statusCode === 409;
           if (doesAccountAlreadyExist) {
-            const account = await this.getSmartAccount(options);
+            const account = await this._getSmartAccountInternal(options);
             return account;
           }
           throw error;
@@ -837,6 +819,26 @@ export class EvmClient implements EvmClientInterface {
     };
   }
 
+  /**
+   * Lists the spend permissions for a smart account.
+   *
+   * @param {ListSpendPermissionsOptions} options - Parameters for listing the spend permissions.
+   * @param {string} options.address - The address of the smart account.
+   * @param {number} [options.pageSize] - The number of spend permissions to return.
+   * @param {string} [options.pageToken] - The page token to return the next page of spend permissions.
+   *
+   * @returns A promise that resolves to the spend permissions.
+   */
+  async listSpendPermissions(
+    options: ListSpendPermissionsOptions,
+  ): Promise<ListSpendPermissionsResult> {
+    Analytics.trackAction({
+      action: "list_spend_permissions",
+    });
+
+    return listSpendPermissions(CdpOpenApiClient, options);
+  }
+
   /**
    * Prepares a user operation for a smart account.
    *
@@ -1365,4 +1367,121 @@ export class EvmClient implements EvmClientInterface {
       ...options,
     });
   }
+
+  /**
+   * Internal method to create an account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {CreateServerAccountOptions} options - Parameters for creating the account.
+   * @returns {Promise<ServerAccount>} A promise that resolves to the newly created account.
+   */
+  private async _createAccountInternal(
+    options: CreateServerAccountOptions = {},
+  ): Promise<ServerAccount> {
+    const openApiAccount = await CdpOpenApiClient.createEvmAccount(
+      {
+        name: options.name,
+        accountPolicy: options.accountPolicy,
+      },
+      options.idempotencyKey,
+    );
+
+    const account = toEvmServerAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
+
+  /**
+   * Internal method to get an account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {GetServerAccountOptions} options - Parameters for getting the account.
+   * @returns {Promise<ServerAccount>} A promise that resolves to the account.
+   */
+  private async _getAccountInternal(options: GetServerAccountOptions): Promise<ServerAccount> {
+    const openApiAccount = await (() => {
+      if (options.address) {
+        return CdpOpenApiClient.getEvmAccount(options.address);
+      }
+
+      if (options.name) {
+        return CdpOpenApiClient.getEvmAccountByName(options.name);
+      }
+
+      throw new UserInputValidationError("Either address or name must be provided");
+    })();
+
+    const account = toEvmServerAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
+
+  /**
+   * Internal method to create a smart account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {CreateSmartAccountOptions} options - Parameters for creating the smart account.
+   * @returns {Promise<SmartAccount>} A promise that resolves to the newly created smart account.
+   */
+  private async _createSmartAccountInternal(
+    options: CreateSmartAccountOptions,
+  ): Promise<SmartAccount> {
+    const owners = [options.owner.address];
+
+    if (options.__experimental_enableSpendPermission) {
+      owners.push(SPEND_PERMISSION_MANAGER_ADDRESS);
+    }
+
+    const openApiSmartAccount = await CdpOpenApiClient.createEvmSmartAccount(
+      {
+        owners: owners,
+        name: options.name,
+      },
+      options.idempotencyKey,
+    );
+
+    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
+      smartAccount: openApiSmartAccount,
+      owner: options.owner,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
+
+    return smartAccount;
+  }
+
+  /**
+   * Internal method to get a smart account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {GetSmartAccountOptions} options - Parameters for getting the smart account.
+   * @returns {Promise<SmartAccount>} A promise that resolves to the smart account.
+   */
+  private async _getSmartAccountInternal(options: GetSmartAccountOptions): Promise<SmartAccount> {
+    const openApiSmartAccount = await (async () => {
+      if (options.address) {
+        return CdpOpenApiClient.getEvmSmartAccount(options.address);
+      } else if (options.name) {
+        return CdpOpenApiClient.getEvmSmartAccountByName(options.name);
+      }
+      throw new UserInputValidationError("Either address or name must be provided");
+    })();
+
+    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
+      smartAccount: openApiSmartAccount,
+      owner: options.owner,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
+
+    return smartAccount;
+  }
 }

package/client/evm/evm.types.ts

@@ -23,6 +23,7 @@ import type {
   EvmSwapsNetwork,
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
+  ListSpendPermissionsResult,
   OpenApiEvmMethods,
   UpdateEvmAccountBody as UpdateEvmAccount,
   UpdateEvmSmartAccountBody as UpdateEvmSmartAccount,
@@ -88,6 +89,9 @@ export type EvmClientInterface = Omit<
   updateSmartAccount: (options: UpdateEvmSmartAccountOptions) => Promise<SmartAccount>;
   listAccounts: (options: ListServerAccountsOptions) => Promise<ListServerAccountResult>;
   listSmartAccounts: (options: ListSmartAccountsOptions) => Promise<ListSmartAccountResult>;
+  listSpendPermissions: (
+    options: ListSpendPermissionsOptions,
+  ) => Promise<ListSpendPermissionsResult>;
   listTokenBalances: (options: ListTokenBalancesOptions) => Promise<ListTokenBalancesResult>;
   prepareUserOperation: (options: PrepareUserOperationOptions) => Promise<UserOperation>;
   requestFaucet: (options: RequestFaucetOptions) => Promise<RequestFaucetResult>;

package/client/policies/policies.ts

@@ -13,8 +13,7 @@ import {
   CreatePolicyBody,
   UpdatePolicyBody,
 } from "../../openapi-client/index.js";
-import { CreatePolicyBodySchema, UpdatePolicyBodySchema } from "../../policies/schema.js";
-import { Policy } from "../../policies/types.js";
+import { Policy, CreatePolicyBodySchema, UpdatePolicyBodySchema } from "../../policies/types.js";
 
 /**
  * The namespace containing all Policy methods.
@@ -80,7 +79,7 @@ export class PoliciesClient implements PoliciesClientInterface {
    * @returns {Promise<Policy>} The created policy
    * @throws {ZodError<typeof CreatePolicyBodySchema>} When the policy is invalid
    *
-   * @example **Creating a new policy**
+   * @example **Creating a new EVM policy**
    *          ```ts
    *          const policy = await cdp.policies.createPolicy({
    *            policy: {
@@ -103,6 +102,45 @@ export class PoliciesClient implements PoliciesClientInterface {
    *          });
    *          ```
    *
+   * @example **Creating a new Solana policy**
+   *          ```ts
+   *          const policy = await cdp.policies.createPolicy({
+   *            policy: {
+   *              scope: "account",
+   *              description: "Limits SOL transfers and SPL token operations",
+   *              rules: [
+   *                {
+   *                  action: "reject",
+   *                  operation: "signSolTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "solValue",
+   *                      solValue: "1000000000", // 1 SOL in lamports
+   *                      operator: ">",
+   *                    },
+   *                    {
+   *                      type: "solAddress",
+   *                      addresses: ["9xQeWvG816bUx9EPjHmaT23yvVM2ZWbrrpZb9PusVFin"],
+   *                      operator: "in",
+   *                    },
+   *                  ],
+   *                },
+   *                {
+   *                  action: "accept",
+   *                  operation: "sendSolTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "mintAddress",
+   *                      addresses: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint
+   *                      operator: "in",
+   *                    },
+   *                  ],
+   *                },
+   *              ],
+   *            }
+   *          });
+   *          ```
+   *
    * @example **With idempotency key**
    *          ```ts
    *          const idempotencyKey = uuidv4();
@@ -229,7 +267,7 @@ export class PoliciesClient implements PoliciesClientInterface {
    * @returns {Promise<Policy>} The updated policy
    * @throws {ZodError<typeof UpdatePolicyBodySchema>} When the updated policy is invalid
    *
-   * @example **Updating a policy**
+   * @example **Updating an EVM policy**
    *          ```ts
    *          const updatedPolicy = await cdp.policies.updatePolicy({
    *            id: "__ID__",
@@ -252,6 +290,34 @@ export class PoliciesClient implements PoliciesClientInterface {
    *          });
    *          ```
    *
+   * @example **Updating a Solana policy**
+   *          ```ts
+   *          const updatedPolicy = await cdp.policies.updatePolicy({
+   *            id: "__ID__",
+   *            policy: {
+   *              description: "Updated Solana transaction limits",
+   *              rules: [
+   *                {
+   *                  action: "reject",
+   *                  operation: "signSolTransaction",
+   *                  criteria: [
+   *                    {
+   *                      type: "splValue",
+   *                      splValue: "1000000", // SPL token amount
+   *                      operator: ">=",
+   *                    },
+   *                    {
+   *                      type: "mintAddress",
+   *                      addresses: ["EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"], // USDC mint
+   *                      operator: "in",
+   *                    },
+   *                  ],
+   *                },
+   *              ],
+   *            },
+   *          });
+   *          ```
+   *
    * @example **With idempotency key**
    *          ```ts
    *          const idempotencyKey = uuidv4();

package/client/policies/policies.types.ts

@@ -1,6 +1,5 @@
 import { OpenApiPoliciesMethods } from "../../openapi-client/index.js";
-import { CreatePolicyBody, PolicyScope, UpdatePolicyBody } from "../../policies/schema.js";
-import { Policy } from "../../policies/types.js";
+import { CreatePolicyBody, Policy, PolicyScope, UpdatePolicyBody } from "../../policies/types.js";
 
 /**
  * The PoliciesClient type, where all OpenApiPoliciesMethods methods are wrapped.

package/client/solana/solana.ts

@@ -83,21 +83,7 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    const openApiAccount = await CdpOpenApiClient.createSolanaAccount(
-      {
-        name: options.name,
-        accountPolicy: options.accountPolicy,
-      },
-      options.idempotencyKey,
-    );
-
-    const account = toSolanaAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
-    return account;
+    return this._createAccountInternal(options);
   }
 
   /**
@@ -279,25 +265,7 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    const openApiAccount = await (() => {
-      if (options.address) {
-        return CdpOpenApiClient.getSolanaAccount(options.address);
-      }
-
-      if (options.name) {
-        return CdpOpenApiClient.getSolanaAccountByName(options.name);
-      }
-
-      throw new UserInputValidationError("Either address or name must be provided");
-    })();
-
-    const account = toSolanaAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
-
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
-    return account;
+    return this._getAccountInternal(options);
   }
 
   /**
@@ -322,20 +290,20 @@ export class SolanaClient implements SolanaClientInterface {
     });
 
     try {
-      const account = await this.getAccount(options);
+      const account = await this._getAccountInternal(options);
       return account;
     } catch (error) {
       // If it failed because the account doesn't exist, create it
       const doesAccountNotExist = error instanceof APIError && error.statusCode === 404;
       if (doesAccountNotExist) {
         try {
-          const account = await this.createAccount(options);
+          const account = await this._createAccountInternal(options);
           return account;
         } catch (error) {
-          // If it failed because the account already exists, throw an error
+          // If it failed because the account already exists, get the existing account
           const doesAccountAlreadyExist = error instanceof APIError && error.statusCode === 409;
           if (doesAccountAlreadyExist) {
-            const account = await this.getAccount(options);
+            const account = await this._getAccountInternal(options);
             return account;
           }
           throw error;
@@ -643,4 +611,58 @@ export class SolanaClient implements SolanaClientInterface {
       nextPageToken: tokenBalances.nextPageToken,
     };
   }
+
+  /**
+   * Internal method to create a Solana account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {CreateAccountOptions} options - Parameters for creating the account.
+   * @returns {Promise<SolanaAccount>} A promise that resolves to the newly created account.
+   */
+  private async _createAccountInternal(options: CreateAccountOptions = {}): Promise<SolanaAccount> {
+    const openApiAccount = await CdpOpenApiClient.createSolanaAccount(
+      {
+        name: options.name,
+        accountPolicy: options.accountPolicy,
+      },
+      options.idempotencyKey,
+    );
+
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
+
+  /**
+   * Internal method to get a Solana account without tracking analytics.
+   * Used internally by composite operations to avoid double-counting.
+   *
+   * @param {GetAccountOptions} options - Parameters for getting the account.
+   * @returns {Promise<SolanaAccount>} A promise that resolves to the account.
+   */
+  private async _getAccountInternal(options: GetAccountOptions): Promise<SolanaAccount> {
+    const openApiAccount = await (() => {
+      if (options.address) {
+        return CdpOpenApiClient.getSolanaAccount(options.address);
+      }
+
+      if (options.name) {
+        return CdpOpenApiClient.getSolanaAccountByName(options.name);
+      }
+
+      throw new UserInputValidationError("Either address or name must be provided");
+    })();
+
+    const account = toSolanaAccount(CdpOpenApiClient, {
+      account: openApiAccount,
+    });
+
+    Analytics.wrapObjectMethodsWithErrorTracking(account);
+
+    return account;
+  }
 }

package/index.ts

@@ -6,7 +6,7 @@ export {
   UpdatePolicyBodySchema,
   type CreatePolicyBody,
   type UpdatePolicyBody,
-} from "./policies/schema.js";
+} from "./policies/types.js";
 export { NetworkError } from "./openapi-client/errors.js";
 export type { SpendPermission } from "./spend-permissions/types.js";
 export {