@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/client/evm/evm.types.ts

@@ -24,6 +24,9 @@ import type {
 } from "../../actions/evm/sendUserOperation.js";
 import type { SmartAccountActions } from "../../actions/evm/types.js";
 import type {
+  CreateEvmEip7702DelegationResult as CreateEvmEip7702DelegationResultApi,
+  EvmEip7702DelegationNetwork,
+  EvmEip7702DelegationOperation,
   EvmSwapsNetwork,
   EvmUserOperationNetwork,
   EvmUserOperationStatus,
@@ -37,6 +40,9 @@ import type { Calls } from "../../types/calls.js";
 import type { Address, EIP712Message, Hex } from "../../types/misc.js";
 import type { WaitOptions } from "../../utils/wait.js";
 
+/** Result of createEvmEip7702Delegation with delegationOperationId. */
+export type CreateEvmEip7702DelegationResult = CreateEvmEip7702DelegationResultApi;
+
 /**
  * The EvmClient type, where all OpenApiEvmMethods methods are wrapped.
  */
@@ -75,6 +81,8 @@ export type EvmClientInterface = Omit<
   | "exportEvmAccount"
   | "exportEvmAccountByName"
   | "updateEvmSmartAccount" // 🚧 Coming soon
+  | "createEvmEip7702Delegation" // mapped to options-based createEvmEip7702Delegation
+  | "getEvmEip7702DelegationOperationById" // wrapped as getEvmEip7702DelegationOperationById
 > & {
   createAccount: (options: CreateServerAccountOptions) => Promise<ServerAccount>;
   createSmartAccount: (options: CreateSmartAccountOptions) => Promise<SmartAccount>;
@@ -111,6 +119,15 @@ export type EvmClientInterface = Omit<
   signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
   signTypedData: (options: SignTypedDataOptions) => Promise<SignatureResult>;
   signTransaction: (options: SignTransactionOptions) => Promise<SignatureResult>;
+  createEvmEip7702Delegation: (
+    options: CreateEvmEip7702DelegationOptions,
+  ) => Promise<CreateEvmEip7702DelegationResult>;
+  getEvmEip7702DelegationOperationById: (
+    delegationOperationId: string,
+  ) => Promise<EvmEip7702DelegationOperation>;
+  waitForEvmEip7702DelegationOperationStatus: (
+    options: WaitForEvmEip7702DelegationOperationStatusOptions,
+  ) => Promise<EvmEip7702DelegationOperation>;
 };
 
 export type { ServerAccount, SmartAccount };
@@ -451,8 +468,10 @@ export interface ListServerAccountsOptions {
 /**
  * A smart account that only contains the owner address.
  */
-export interface ReadonlySmartAccount
-  extends Omit<SmartAccount, "owners" | keyof SmartAccountActions | "useNetwork"> {
+export interface ReadonlySmartAccount extends Omit<
+  SmartAccount,
+  "owners" | keyof SmartAccountActions | "useNetwork"
+> {
   /** The owners of the smart account. */
   owners: Address[];
 }
@@ -483,6 +502,30 @@ export interface UpdateEvmSmartAccountOptions {
   owner: Account;
 }
 
+/**
+ * Options for creating an EIP-7702 delegation for an EVM EOA account.
+ */
+export interface CreateEvmEip7702DelegationOptions {
+  /** The address of the EOA account. */
+  address: Address;
+  /** The network for the EIP-7702 delegation. */
+  network: EvmEip7702DelegationNetwork;
+  /** Whether to configure spend permissions for the upgraded, delegated account. When enabled, the account can grant permissions for third parties to spend on its behalf. Defaults to false. */
+  enableSpendPermissions?: boolean;
+  /** Optional idempotency key. */
+  idempotencyKey?: string;
+}
+
+/**
+ * Options for waiting for an EIP-7702 delegation operation to complete.
+ */
+export interface WaitForEvmEip7702DelegationOperationStatusOptions {
+  /** The delegation operation ID returned by createEvmEip7702Delegation. */
+  delegationOperationId: string;
+  /** Optional options for the wait operation. */
+  waitOptions?: WaitOptions;
+}
+
 /**
  * The result of listing EVM smart accounts.
  */

package/client/policies/policies.ts

@@ -68,7 +68,12 @@ export class PoliciesClient implements PoliciesClientInterface {
       },
     });
 
-    return CdpOpenApiClient.listPolicies(options) as Promise<ListPoliciesResult>;
+    try {
+      return CdpOpenApiClient.listPolicies(options) as Promise<ListPoliciesResult>;
+    } catch (error) {
+      Analytics.trackError(error, "listPolicies");
+      throw error;
+    }
   }
 
   /**
@@ -186,13 +191,18 @@ export class PoliciesClient implements PoliciesClientInterface {
       },
     });
 
-    CreatePolicyBodySchema.parse(options.policy);
-    return CdpOpenApiClient.createPolicy(
-      // There are arbitrary differences between the abitype Abi and the openapi Abi
-      options.policy as CreatePolicyBody,
+    try {
+      CreatePolicyBodySchema.parse(options.policy);
+      return CdpOpenApiClient.createPolicy(
+        // There are arbitrary differences between the abitype Abi and the openapi Abi
+        options.policy as CreatePolicyBody,
 
-      options.idempotencyKey,
-    ) as Promise<Policy>;
+        options.idempotencyKey,
+      ) as Promise<Policy>;
+    } catch (error) {
+      Analytics.trackError(error, "createPolicy");
+      throw error;
+    }
   }
 
   /**
@@ -218,7 +228,12 @@ export class PoliciesClient implements PoliciesClientInterface {
       action: "get_policy_by_id",
     });
 
-    return CdpOpenApiClient.getPolicyById(options.id) as Promise<Policy>;
+    try {
+      return CdpOpenApiClient.getPolicyById(options.id) as Promise<Policy>;
+    } catch (error) {
+      Analytics.trackError(error, "getPolicyById");
+      throw error;
+    }
   }
 
   /**
@@ -254,7 +269,12 @@ export class PoliciesClient implements PoliciesClientInterface {
       action: "delete_policy",
     });
 
-    return CdpOpenApiClient.deletePolicy(options.id, options.idempotencyKey);
+    try {
+      return CdpOpenApiClient.deletePolicy(options.id, options.idempotencyKey);
+    } catch (error) {
+      Analytics.trackError(error, "deletePolicy");
+      throw error;
+    }
   }
 
   /**
@@ -342,12 +362,17 @@ export class PoliciesClient implements PoliciesClientInterface {
       action: "update_policy",
     });
 
-    UpdatePolicyBodySchema.parse(options.policy);
-    return CdpOpenApiClient.updatePolicy(
-      options.id,
-      // There are arbitrary differences between the abitype Abi and the openapi Abi
-      options.policy as UpdatePolicyBody,
-      options.idempotencyKey,
-    ) as Promise<Policy>;
+    try {
+      UpdatePolicyBodySchema.parse(options.policy);
+      return CdpOpenApiClient.updatePolicy(
+        options.id,
+        // There are arbitrary differences between the abitype Abi and the openapi Abi
+        options.policy as UpdatePolicyBody,
+        options.idempotencyKey,
+      ) as Promise<Policy>;
+    } catch (error) {
+      Analytics.trackError(error, "updatePolicy");
+      throw error;
+    }
   }
 }

package/client/solana/solana.ts

@@ -87,7 +87,12 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    return this._createAccountInternal(options);
+    try {
+      return this._createAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "createAccount");
+      throw error;
+    }
   }
 
   /**
@@ -120,34 +125,41 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    const { publicKey, privateKey } = await generateExportEncryptionKeyPair();
-
-    const { encryptedPrivateKey } = await (async () => {
-      if (options.address) {
-        return CdpOpenApiClient.exportSolanaAccount(
-          options.address,
-          {
-            exportEncryptionKey: publicKey,
-          },
-          options.idempotencyKey,
-        );
-      }
+    try {
+      const { publicKey, privateKey } = await generateExportEncryptionKeyPair();
+
+      const { encryptedPrivateKey } = await (async () => {
+        if (options.address) {
+          return CdpOpenApiClient.exportSolanaAccount(
+            options.address,
+            {
+              exportEncryptionKey: publicKey,
+            },
+            options.idempotencyKey,
+          );
+        }
 
-      if (options.name) {
-        return CdpOpenApiClient.exportSolanaAccountByName(
-          options.name,
-          {
-            exportEncryptionKey: publicKey,
-          },
-          options.idempotencyKey,
-        );
-      }
+        if (options.name) {
+          return CdpOpenApiClient.exportSolanaAccountByName(
+            options.name,
+            {
+              exportEncryptionKey: publicKey,
+            },
+            options.idempotencyKey,
+          );
+        }
 
-      throw new UserInputValidationError("Either address or name must be provided");
-    })();
+        throw new UserInputValidationError("Either address or name must be provided");
+      })();
 
-    const decryptedPrivateKey = decryptWithPrivateKey(privateKey, encryptedPrivateKey);
-    return formatSolanaPrivateKey(decryptedPrivateKey);
+      const decryptedPrivateKey = decryptWithPrivateKey(privateKey, encryptedPrivateKey);
+      return await formatSolanaPrivateKey(decryptedPrivateKey);
+    } catch (error) {
+      if (!(error instanceof UserInputValidationError)) {
+        Analytics.trackError(error, "exportAccount");
+      }
+      throw error;
+    }
   }
 
   /**
@@ -194,48 +206,53 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    let privateKeyBytes: Uint8Array = new Uint8Array();
-
-    if (typeof options.privateKey === "string") {
-      privateKeyBytes = bs58.decode(options.privateKey);
-    } else {
-      privateKeyBytes = options.privateKey;
-    }
-
-    if (privateKeyBytes.length !== 32 && privateKeyBytes.length !== 64) {
-      throw new UserInputValidationError("Invalid private key length");
-    }
-
-    if (privateKeyBytes.length === 64) {
-      privateKeyBytes = privateKeyBytes.subarray(0, 32);
-    }
-
-    const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
+    try {
+      let privateKeyBytes: Uint8Array = new Uint8Array();
 
-    const encryptedPrivateKey = publicEncrypt(
-      {
-        key: encryptionPublicKey,
-        padding: constants.RSA_PKCS1_OAEP_PADDING,
-        oaepHash: "sha256",
-      },
-      privateKeyBytes,
-    );
+      if (typeof options.privateKey === "string") {
+        privateKeyBytes = bs58.decode(options.privateKey);
+      } else {
+        privateKeyBytes = options.privateKey;
+      }
 
-    const openApiAccount = await CdpOpenApiClient.importSolanaAccount(
-      {
-        encryptedPrivateKey: encryptedPrivateKey.toString("base64"),
-        name: options.name,
-      },
-      options.idempotencyKey,
-    );
+      if (privateKeyBytes.length !== 32 && privateKeyBytes.length !== 64) {
+        throw new UserInputValidationError("Invalid private key length");
+      }
 
-    const account = toSolanaAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
+      if (privateKeyBytes.length === 64) {
+        privateKeyBytes = privateKeyBytes.subarray(0, 32);
+      }
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
+      const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
+
+      const encryptedPrivateKey = publicEncrypt(
+        {
+          key: encryptionPublicKey,
+          padding: constants.RSA_PKCS1_OAEP_PADDING,
+          oaepHash: "sha256",
+        },
+        privateKeyBytes,
+      );
+
+      const openApiAccount = await CdpOpenApiClient.importSolanaAccount(
+        {
+          encryptedPrivateKey: encryptedPrivateKey.toString("base64"),
+          name: options.name,
+        },
+        options.idempotencyKey,
+      );
+
+      const account = toSolanaAccount(CdpOpenApiClient, {
+        account: openApiAccount,
+      });
 
-    return account;
+      return account;
+    } catch (error) {
+      if (!(error instanceof UserInputValidationError)) {
+        Analytics.trackError(error, "importAccount");
+      }
+      throw error;
+    }
   }
 
   /**
@@ -269,7 +286,12 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    return this._getAccountInternal(options);
+    try {
+      return this._getAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "getAccount");
+      throw error;
+    }
   }
 
   /**
@@ -294,26 +316,31 @@ export class SolanaClient implements SolanaClientInterface {
     });
 
     try {
-      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._createAccountInternal(options);
-          return account;
-        } catch (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._getAccountInternal(options);
+      try {
+        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._createAccountInternal(options);
             return account;
+          } catch (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._getAccountInternal(options);
+              return account;
+            }
+            throw error;
           }
-          throw error;
         }
-      }
 
+        throw error;
+      }
+    } catch (error) {
+      Analytics.trackError(error, "getOrCreateAccount");
       throw error;
     }
   }
@@ -352,23 +379,26 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    const solAccounts = await CdpOpenApiClient.listSolanaAccounts({
-      pageSize: options.pageSize,
-      pageToken: options.pageToken,
-    });
-
-    return {
-      accounts: solAccounts.accounts.map(account => {
-        const solanaAccount = toSolanaAccount(CdpOpenApiClient, {
-          account,
-        });
-
-        Analytics.wrapObjectMethodsWithErrorTracking(solanaAccount);
-
-        return solanaAccount;
-      }),
-      nextPageToken: solAccounts.nextPageToken,
-    };
+    try {
+      const solAccounts = await CdpOpenApiClient.listSolanaAccounts({
+        pageSize: options.pageSize,
+        pageToken: options.pageToken,
+      });
+
+      return {
+        accounts: solAccounts.accounts.map(account => {
+          const solanaAccount = toSolanaAccount(CdpOpenApiClient, {
+            account,
+          });
+
+          return solanaAccount;
+        }),
+        nextPageToken: solAccounts.nextPageToken,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "listAccounts");
+      throw error;
+    }
   }
 
   /**
@@ -395,7 +425,12 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    return requestFaucet(CdpOpenApiClient, options);
+    try {
+      return requestFaucet(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "requestFaucet");
+      throw error;
+    }
   }
 
   /**
@@ -426,7 +461,12 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    return signMessage(CdpOpenApiClient, options);
+    try {
+      return signMessage(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "signMessage");
+      throw error;
+    }
   }
 
   /**
@@ -444,18 +484,44 @@ export class SolanaClient implements SolanaClientInterface {
    * // 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
+   * // Build your transaction using @solana/kit
+   * import {
+   *   address as solanaAddress,
+   *   appendTransactionMessageInstructions,
+   *   compileTransaction,
+   *   createNoopSigner,
+   *   createSolanaRpc,
+   *   createTransactionMessage,
+   *   getBase64EncodedWireTransaction,
+   *   pipe,
+   *   setTransactionMessageFeePayer,
+   *   setTransactionMessageLifetimeUsingBlockhash,
+   * } from "@solana/kit";
+   * import { getTransferSolInstruction } from "@solana-program/system";
+   *
+   * const rpc = createSolanaRpc("https://api.devnet.solana.com");
+   * const { value: { blockhash, lastValidBlockHeight } } = await rpc.getLatestBlockhash().send();
+   *
+   * const txMsg = pipe(
+   *   createTransactionMessage({ version: 0 }),
+   *   (tx) => setTransactionMessageFeePayer(solanaAddress(account.address), tx),
+   *   (tx) => setTransactionMessageLifetimeUsingBlockhash(
+   *     { blockhash, lastValidBlockHeight },
+   *     tx,
+   *   ),
+   *   (tx) => appendTransactionMessageInstructions([
+   *     getTransferSolInstruction({
+   *       source: createNoopSigner(solanaAddress(account.address)),
+   *       destination: solanaAddress("3KzDtddx4i53FBkvCzuDmRbaMozTZoJBb1TToWhz3JfE"),
+   *       amount: 10000n,
+   *     }),
+   *   ], tx),
+   * );
+   *
+   * // Base64 encode the compiled transaction
+   * const transaction = getBase64EncodedWireTransaction(compileTransaction(txMsg));
+   *
+   * // Sign the transaction via the CDP API
    * const signature = await cdp.solana.signTransaction({
    *   address: account.address,
    *   transaction,
@@ -468,7 +534,12 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    return signTransaction(CdpOpenApiClient, options);
+    try {
+      return signTransaction(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "signTransaction");
+      throw error;
+    }
   }
 
   /**
@@ -518,19 +589,22 @@ export class SolanaClient implements SolanaClientInterface {
       accountType: "solana",
     });
 
-    const openApiAccount = await CdpOpenApiClient.updateSolanaAccount(
-      options.address,
-      options.update,
-      options.idempotencyKey,
-    );
-
-    const account = toSolanaAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
+    try {
+      const openApiAccount = await CdpOpenApiClient.updateSolanaAccount(
+        options.address,
+        options.update,
+        options.idempotencyKey,
+      );
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
+      const account = toSolanaAccount(CdpOpenApiClient, {
+        account: openApiAccount,
+      });
 
-    return account;
+      return account;
+    } catch (error) {
+      Analytics.trackError(error, "updateAccount");
+      throw error;
+    }
   }
 
   /**
@@ -560,7 +634,12 @@ export class SolanaClient implements SolanaClientInterface {
       },
     });
 
-    return sendTransaction(CdpOpenApiClient, options);
+    try {
+      return sendTransaction(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "sendTransaction");
+      throw error;
+    }
   }
 
   /**
@@ -589,31 +668,36 @@ export class SolanaClient implements SolanaClientInterface {
       },
     });
 
-    const tokenBalances = await CdpOpenApiClient.listSolanaTokenBalances(
-      options.network || "solana",
-      options.address,
-      {
-        pageSize: options.pageSize,
-        pageToken: options.pageToken,
-      },
-    );
-
-    return {
-      balances: tokenBalances.balances.map(balance => {
-        return {
-          amount: {
-            amount: BigInt(balance.amount.amount),
-            decimals: balance.amount.decimals,
-          },
-          token: {
-            mintAddress: balance.token.mintAddress,
-            name: balance.token.name,
-            symbol: balance.token.symbol,
-          },
-        };
-      }),
-      nextPageToken: tokenBalances.nextPageToken,
-    };
+    try {
+      const tokenBalances = await CdpOpenApiClient.listSolanaTokenBalances(
+        options.network || "solana",
+        options.address,
+        {
+          pageSize: options.pageSize,
+          pageToken: options.pageToken,
+        },
+      );
+
+      return {
+        balances: tokenBalances.balances.map(balance => {
+          return {
+            amount: {
+              amount: BigInt(balance.amount.amount),
+              decimals: balance.amount.decimals,
+            },
+            token: {
+              mintAddress: balance.token.mintAddress,
+              name: balance.token.name,
+              symbol: balance.token.symbol,
+            },
+          };
+        }),
+        nextPageToken: tokenBalances.nextPageToken,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "listTokenBalances");
+      throw error;
+    }
   }
 
   /**
@@ -636,8 +720,6 @@ export class SolanaClient implements SolanaClientInterface {
       account: openApiAccount,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
     return account;
   }
 
@@ -665,8 +747,6 @@ export class SolanaClient implements SolanaClientInterface {
       account: openApiAccount,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
     return account;
   }
 }