@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/client/evm/evm.ts

@@ -7,6 +7,7 @@ import { constants, publicEncrypt } from "crypto";
 import { type Address, getTypesForEIP712Domain } from "viem";
 
 import {
+  CreateEvmEip7702DelegationResult,
   CreateServerAccountOptions,
   CreateSmartAccountOptions,
   CreateSwapQuoteOptions,
@@ -67,6 +68,7 @@ import {
 import { resolveSpendPermission } from "../../actions/evm/spend-permissions/resolveSpendPermission.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { getSwapPrice } from "../../actions/evm/swap/getSwapPrice.js";
+import { waitForEvmEip7702DelegationOperationStatus } from "../../actions/evm/waitForEvmEip7702DelegationStatus.js";
 import {
   waitForUserOperation,
   WaitForUserOperationReturnType,
@@ -77,6 +79,7 @@ import { UserInputValidationError } from "../../errors.js";
 import { APIError } from "../../openapi-client/errors.js";
 import {
   CdpOpenApiClient,
+  EvmEip7702DelegationOperation,
   EvmUserOperationStatus,
   EIP712Message as OpenAPIEIP712Message,
 } from "../../openapi-client/index.js";
@@ -84,6 +87,10 @@ import { SPEND_PERMISSION_MANAGER_ADDRESS } from "../../spend-permissions/consta
 import { Hex } from "../../types/misc.js";
 import { decryptWithPrivateKey, generateExportEncryptionKeyPair } from "../../utils/export.js";
 
+import type {
+  CreateEvmEip7702DelegationOptions,
+  WaitForEvmEip7702DelegationOperationStatusOptions,
+} from "./evm.types.js";
 import type {
   SendTransactionOptions,
   TransactionResult,
@@ -138,7 +145,12 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    return this._createAccountInternal(options);
+    try {
+      return await this._createAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "createAccount");
+      throw error;
+    }
   }
 
   /**
@@ -189,17 +201,17 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
+    try {
+      const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
 
-    const privateKeyHex = options.privateKey.startsWith("0x")
-      ? options.privateKey.slice(2)
-      : options.privateKey;
+      const privateKeyHex = options.privateKey.startsWith("0x")
+        ? options.privateKey.slice(2)
+        : options.privateKey;
 
-    if (!/^[0-9a-fA-F]+$/.test(privateKeyHex)) {
-      throw new UserInputValidationError("Private key must be a valid hexadecimal string");
-    }
+      if (!/^[0-9a-fA-F]+$/.test(privateKeyHex)) {
+        throw new UserInputValidationError("Private key must be a valid hexadecimal string");
+      }
 
-    try {
       const privateKeyBytes = Buffer.from(privateKeyHex, "hex");
 
       const encryptedPrivateKey = publicEncrypt(
@@ -223,10 +235,12 @@ export class EvmClient implements EvmClientInterface {
         account: openApiAccount,
       });
 
-      Analytics.wrapObjectMethodsWithErrorTracking(account);
-
       return account;
     } catch (error) {
+      if (!(error instanceof UserInputValidationError)) {
+        Analytics.trackError(error, "importAccount");
+      }
+
       if (error instanceof APIError) {
         throw error;
       }
@@ -265,33 +279,40 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    const { publicKey, privateKey } = await generateExportEncryptionKeyPair();
-
-    const { encryptedPrivateKey } = await (async () => {
-      if (options.address) {
-        return CdpOpenApiClient.exportEvmAccount(
-          options.address,
-          {
-            exportEncryptionKey: publicKey,
-          },
-          options.idempotencyKey,
-        );
-      }
+    try {
+      const { publicKey, privateKey } = await generateExportEncryptionKeyPair();
+
+      const { encryptedPrivateKey } = await (async () => {
+        if (options.address) {
+          return CdpOpenApiClient.exportEvmAccount(
+            options.address,
+            {
+              exportEncryptionKey: publicKey,
+            },
+            options.idempotencyKey,
+          );
+        }
 
-      if (options.name) {
-        return CdpOpenApiClient.exportEvmAccountByName(
-          options.name,
-          {
-            exportEncryptionKey: publicKey,
-          },
-          options.idempotencyKey,
-        );
-      }
+        if (options.name) {
+          return CdpOpenApiClient.exportEvmAccountByName(
+            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");
+      })();
 
-    return decryptWithPrivateKey(privateKey, encryptedPrivateKey);
+      return decryptWithPrivateKey(privateKey, encryptedPrivateKey);
+    } catch (error) {
+      if (!(error instanceof UserInputValidationError)) {
+        Analytics.trackError(error, "exportAccount");
+      }
+      throw error;
+    }
   }
 
   /**
@@ -345,7 +366,12 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_smart",
     });
 
-    return this._createSmartAccountInternal(options);
+    try {
+      return await this._createSmartAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "createSmartAccount");
+      throw error;
+    }
   }
 
   /**
@@ -370,38 +396,43 @@ export class EvmClient implements EvmClientInterface {
       action: "create_spend_permission",
     });
 
-    const resolvedSpendPermission = resolveSpendPermission(
-      options.spendPermission,
-      options.network,
-    );
+    try {
+      const resolvedSpendPermission = resolveSpendPermission(
+        options.spendPermission,
+        options.network,
+      );
 
-    const userOperation = await CdpOpenApiClient.createSpendPermission(
-      resolvedSpendPermission.account,
-      {
-        spender: resolvedSpendPermission.spender,
-        token: resolvedSpendPermission.token,
-        allowance: resolvedSpendPermission.allowance.toString(),
-        period: resolvedSpendPermission.period.toString(),
-        start: resolvedSpendPermission.start.toString(),
-        end: resolvedSpendPermission.end.toString(),
-        salt: resolvedSpendPermission.salt.toString(),
-        extraData: resolvedSpendPermission.extraData,
-        network: options.network,
-        paymasterUrl: options.paymasterUrl,
-      },
-      options.idempotencyKey,
-    );
+      const userOperation = await CdpOpenApiClient.createSpendPermission(
+        resolvedSpendPermission.account,
+        {
+          spender: resolvedSpendPermission.spender,
+          token: resolvedSpendPermission.token,
+          allowance: resolvedSpendPermission.allowance.toString(),
+          period: resolvedSpendPermission.period.toString(),
+          start: resolvedSpendPermission.start.toString(),
+          end: resolvedSpendPermission.end.toString(),
+          salt: resolvedSpendPermission.salt.toString(),
+          extraData: resolvedSpendPermission.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,
-      })),
-    };
+      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,
+        })),
+      };
+    } catch (error) {
+      Analytics.trackError(error, "createSpendPermission");
+      throw error;
+    }
   }
 
   /**
@@ -429,26 +460,31 @@ export class EvmClient implements EvmClientInterface {
       action: "revoke_spend_permission",
     });
 
-    const userOperation = await CdpOpenApiClient.revokeSpendPermission(
-      options.address,
-      {
-        network: options.network,
-        permissionHash: options.permissionHash,
-        paymasterUrl: options.paymasterUrl,
-      },
-      options.idempotencyKey,
-    );
+    try {
+      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,
-      })),
-    };
+      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,
+        })),
+      };
+    } catch (error) {
+      Analytics.trackError(error, "revokeSpendPermission");
+      throw error;
+    }
   }
 
   /**
@@ -482,7 +518,12 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    return this._getAccountInternal(options);
+    try {
+      return await this._getAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "getAccount");
+      throw error;
+    }
   }
 
   /**
@@ -512,7 +553,12 @@ export class EvmClient implements EvmClientInterface {
       action: "get_smart_account",
     });
 
-    return this._getSmartAccountInternal(options);
+    try {
+      return await this._getSmartAccountInternal(options);
+    } catch (error) {
+      Analytics.trackError(error, "getSmartAccount");
+      throw error;
+    }
   }
 
   /**
@@ -537,25 +583,30 @@ export class EvmClient implements EvmClientInterface {
     });
 
     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;
     }
   }
@@ -586,25 +637,30 @@ export class EvmClient implements EvmClientInterface {
     });
 
     try {
-      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._createSmartAccountInternal(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._getSmartAccountInternal(options);
+      try {
+        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._createSmartAccountInternal(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._getSmartAccountInternal(options);
+              return account;
+            }
+            throw error;
           }
-          throw error;
         }
+        throw error;
       }
+    } catch (error) {
+      Analytics.trackError(error, "getOrCreateSmartAccount");
       throw error;
     }
   }
@@ -637,7 +693,12 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return getSwapPrice(CdpOpenApiClient, options);
+    try {
+      return await getSwapPrice(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "getSwapPrice");
+      throw error;
+    }
   }
 
   /**
@@ -668,7 +729,12 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return createSwapQuote(CdpOpenApiClient, options);
+    try {
+      return await createSwapQuote(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "createSwapQuote");
+      throw error;
+    }
   }
 
   /**
@@ -693,7 +759,12 @@ export class EvmClient implements EvmClientInterface {
       action: "get_user_operation",
     });
 
-    return getUserOperation(CdpOpenApiClient, options);
+    try {
+      return await getUserOperation(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "getUserOperation");
+      throw error;
+    }
   }
 
   /**
@@ -726,23 +797,26 @@ export class EvmClient implements EvmClientInterface {
       accountType: "evm_server",
     });
 
-    const ethAccounts = await CdpOpenApiClient.listEvmAccounts({
-      pageSize: options.pageSize,
-      pageToken: options.pageToken,
-    });
-
-    return {
-      accounts: ethAccounts.accounts.map(account => {
-        const evmAccount = toEvmServerAccount(CdpOpenApiClient, {
-          account,
-        });
+    try {
+      const ethAccounts = await CdpOpenApiClient.listEvmAccounts({
+        pageSize: options.pageSize,
+        pageToken: options.pageToken,
+      });
 
-        Analytics.wrapObjectMethodsWithErrorTracking(evmAccount);
+      return {
+        accounts: ethAccounts.accounts.map(account => {
+          const evmAccount = toEvmServerAccount(CdpOpenApiClient, {
+            account,
+          });
 
-        return evmAccount;
-      }),
-      nextPageToken: ethAccounts.nextPageToken,
-    };
+          return evmAccount;
+        }),
+        nextPageToken: ethAccounts.nextPageToken,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "listAccounts");
+      throw error;
+    }
   }
 
   /**
@@ -787,7 +861,12 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return listTokenBalances(CdpOpenApiClient, options);
+    try {
+      return await listTokenBalances(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "listTokenBalances");
+      throw error;
+    }
   }
 
   /**
@@ -819,20 +898,25 @@ export class EvmClient implements EvmClientInterface {
       action: "list_smart_accounts",
     });
 
-    const smartAccounts = await CdpOpenApiClient.listEvmSmartAccounts({
-      pageSize: options.pageSize,
-      pageToken: options.pageToken,
-    });
+    try {
+      const smartAccounts = await CdpOpenApiClient.listEvmSmartAccounts({
+        pageSize: options.pageSize,
+        pageToken: options.pageToken,
+      });
 
-    return {
-      accounts: smartAccounts.accounts.map(account => ({
-        address: account.address as Address,
-        owners: [account.owners[0] as Address],
-        type: "evm-smart",
-        policies: account.policies,
-      })),
-      nextPageToken: smartAccounts.nextPageToken,
-    };
+      return {
+        accounts: smartAccounts.accounts.map(account => ({
+          address: account.address as Address,
+          owners: [account.owners[0] as Address],
+          type: "evm-smart",
+          policies: account.policies,
+        })),
+        nextPageToken: smartAccounts.nextPageToken,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "listSmartAccounts");
+      throw error;
+    }
   }
 
   /**
@@ -852,7 +936,12 @@ export class EvmClient implements EvmClientInterface {
       action: "list_spend_permissions",
     });
 
-    return listSpendPermissions(CdpOpenApiClient, options);
+    try {
+      return await listSpendPermissions(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "listSpendPermissions");
+      throw error;
+    }
   }
 
   /**
@@ -889,28 +978,33 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    const userOp = await CdpOpenApiClient.prepareUserOperation(options.smartAccount.address, {
-      network: options.network,
-      calls: options.calls.map(call => ({
-        to: call.to as Address,
-        value: call.value.toString(),
-        data: call.data as Hex,
-        overrideGasLimit: call.overrideGasLimit,
-      })),
-      paymasterUrl: options.paymasterUrl,
-      dataSuffix: options.dataSuffix,
-    });
+    try {
+      const userOp = await CdpOpenApiClient.prepareUserOperation(options.smartAccount.address, {
+        network: options.network,
+        calls: options.calls.map(call => ({
+          to: call.to as Address,
+          value: call.value.toString(),
+          data: call.data as Hex,
+          overrideGasLimit: call.overrideGasLimit,
+        })),
+        paymasterUrl: options.paymasterUrl,
+        dataSuffix: options.dataSuffix,
+      });
 
-    return {
-      network: userOp.network,
-      userOpHash: userOp.userOpHash as Hex,
-      status: userOp.status,
-      calls: userOp.calls.map(call => ({
-        to: call.to as Address,
-        value: BigInt(call.value),
-        data: call.data as Hex,
-      })),
-    };
+      return {
+        network: userOp.network,
+        userOpHash: userOp.userOpHash as Hex,
+        status: userOp.status,
+        calls: userOp.calls.map(call => ({
+          to: call.to as Address,
+          value: BigInt(call.value),
+          data: call.data as Hex,
+        })),
+      };
+    } catch (error) {
+      Analytics.trackError(error, "prepareUserOperation");
+      throw error;
+    }
   }
 
   /**
@@ -949,25 +1043,30 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    const userOp = await CdpOpenApiClient.prepareAndSendUserOperation(
-      options.smartAccount.address,
-      {
-        network: options.network,
-        calls: options.calls.map(call => ({
-          to: call.to as Address,
-          value: call.value.toString(),
-          data: call.data as Hex,
-        })),
-        paymasterUrl: options.paymasterUrl,
-      },
-      options.idempotencyKey,
-    );
+    try {
+      const userOp = await CdpOpenApiClient.prepareAndSendUserOperation(
+        options.smartAccount.address,
+        {
+          network: options.network,
+          calls: options.calls.map(call => ({
+            to: call.to as Address,
+            value: call.value.toString(),
+            data: call.data as Hex,
+          })),
+          paymasterUrl: options.paymasterUrl,
+        },
+        options.idempotencyKey,
+      );
 
-    return {
-      smartAccountAddress: options.smartAccount.address as Address,
-      userOpHash: userOp.userOpHash as Hex,
-      status: userOp.status as typeof EvmUserOperationStatus.broadcast,
-    };
+      return {
+        smartAccountAddress: options.smartAccount.address as Address,
+        userOpHash: userOp.userOpHash as Hex,
+        status: userOp.status as typeof EvmUserOperationStatus.broadcast,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "prepareAndSendUserOperation");
+      throw error;
+    }
   }
 
   /**
@@ -998,7 +1097,12 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return requestFaucet(CdpOpenApiClient, options);
+    try {
+      return await requestFaucet(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "requestFaucet");
+      throw error;
+    }
   }
 
   /**
@@ -1055,7 +1159,12 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return sendTransaction(CdpOpenApiClient, options);
+    try {
+      return await sendTransaction(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "sendTransaction");
+      throw error;
+    }
   }
 
   /**
@@ -1096,14 +1205,19 @@ export class EvmClient implements EvmClientInterface {
       },
     });
 
-    return sendUserOperation(CdpOpenApiClient, {
-      smartAccount: options.smartAccount,
-      network: options.network,
-      calls: options.calls,
-      paymasterUrl: options.paymasterUrl,
-      idempotencyKey: options.idempotencyKey,
-      dataSuffix: options.dataSuffix,
-    });
+    try {
+      return await sendUserOperation(CdpOpenApiClient, {
+        smartAccount: options.smartAccount,
+        network: options.network,
+        calls: options.calls,
+        paymasterUrl: options.paymasterUrl,
+        idempotencyKey: options.idempotencyKey,
+        dataSuffix: options.dataSuffix,
+      });
+    } catch (error) {
+      Analytics.trackError(error, "sendUserOperation");
+      throw error;
+    }
   }
 
   /**
@@ -1132,17 +1246,22 @@ export class EvmClient implements EvmClientInterface {
       action: "sign_hash",
     });
 
-    const signature = await CdpOpenApiClient.signEvmHash(
-      options.address,
-      {
-        hash: options.hash,
-      },
-      options.idempotencyKey,
-    );
+    try {
+      const signature = await CdpOpenApiClient.signEvmHash(
+        options.address,
+        {
+          hash: options.hash,
+        },
+        options.idempotencyKey,
+      );
 
-    return {
-      signature: signature.signature as Hex,
-    };
+      return {
+        signature: signature.signature as Hex,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "signHash");
+      throw error;
+    }
   }
 
   /**
@@ -1171,17 +1290,22 @@ export class EvmClient implements EvmClientInterface {
       action: "sign_message",
     });
 
-    const signature = await CdpOpenApiClient.signEvmMessage(
-      options.address,
-      {
-        message: options.message,
-      },
-      options.idempotencyKey,
-    );
+    try {
+      const signature = await CdpOpenApiClient.signEvmMessage(
+        options.address,
+        {
+          message: options.message,
+        },
+        options.idempotencyKey,
+      );
 
-    return {
-      signature: signature.signature as Hex,
-    };
+      return {
+        signature: signature.signature as Hex,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "signMessage");
+      throw error;
+    }
   }
 
   /**
@@ -1234,28 +1358,33 @@ export class EvmClient implements EvmClientInterface {
       action: "sign_typed_data",
     });
 
-    const { domain, message, primaryType } = options;
-    const types = {
-      EIP712Domain: getTypesForEIP712Domain({ domain }),
-      ...options.types,
-    };
-
-    const openApiMessage: OpenAPIEIP712Message = {
-      domain,
-      types,
-      primaryType,
-      message,
-    };
-
-    const signature = await CdpOpenApiClient.signEvmTypedData(
-      options.address,
-      openApiMessage,
-      options.idempotencyKey,
-    );
+    try {
+      const { domain, message, primaryType } = options;
+      const types = {
+        EIP712Domain: getTypesForEIP712Domain({ domain }),
+        ...options.types,
+      };
+
+      const openApiMessage: OpenAPIEIP712Message = {
+        domain,
+        types,
+        primaryType,
+        message,
+      };
+
+      const signature = await CdpOpenApiClient.signEvmTypedData(
+        options.address,
+        openApiMessage,
+        options.idempotencyKey,
+      );
 
-    return {
-      signature: signature.signature as Hex,
-    };
+      return {
+        signature: signature.signature as Hex,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "signTypedData");
+      throw error;
+    }
   }
 
   /**
@@ -1293,17 +1422,22 @@ export class EvmClient implements EvmClientInterface {
       action: "sign_transaction",
     });
 
-    const signature = await CdpOpenApiClient.signEvmTransaction(
-      options.address,
-      {
-        transaction: options.transaction,
-      },
-      options.idempotencyKey,
-    );
+    try {
+      const signature = await CdpOpenApiClient.signEvmTransaction(
+        options.address,
+        {
+          transaction: options.transaction,
+        },
+        options.idempotencyKey,
+      );
 
-    return {
-      signature: signature.signedTransaction as Hex,
-    };
+      return {
+        signature: signature.signedTransaction as Hex,
+      };
+    } catch (error) {
+      Analytics.trackError(error, "signTransaction");
+      throw error;
+    }
   }
 
   /**
@@ -1352,19 +1486,22 @@ export class EvmClient implements EvmClientInterface {
       action: "update_account",
     });
 
-    const openApiAccount = await CdpOpenApiClient.updateEvmAccount(
-      options.address,
-      options.update,
-      options.idempotencyKey,
-    );
-
-    const account = toEvmServerAccount(CdpOpenApiClient, {
-      account: openApiAccount,
-    });
+    try {
+      const openApiAccount = await CdpOpenApiClient.updateEvmAccount(
+        options.address,
+        options.update,
+        options.idempotencyKey,
+      );
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
+      const account = toEvmServerAccount(CdpOpenApiClient, {
+        account: openApiAccount,
+      });
 
-    return account;
+      return account;
+    } catch (error) {
+      Analytics.trackError(error, "updateAccount");
+      throw error;
+    }
   }
 
   /**
@@ -1384,20 +1521,121 @@ export class EvmClient implements EvmClientInterface {
       action: "update_smart_account",
     });
 
-    const openApiSmartAccount = await CdpOpenApiClient.updateEvmSmartAccount(
-      options.address,
-      options.update,
-      options.idempotencyKey,
-    );
+    try {
+      const openApiSmartAccount = await CdpOpenApiClient.updateEvmSmartAccount(
+        options.address,
+        options.update,
+        options.idempotencyKey,
+      );
 
-    const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
-      smartAccount: openApiSmartAccount,
-      owner: options.owner,
+      const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
+        smartAccount: openApiSmartAccount,
+        owner: options.owner,
+      });
+
+      return smartAccount;
+    } catch (error) {
+      Analytics.trackError(error, "updateSmartAccount");
+      throw error;
+    }
+  }
+
+  /**
+   * Creates an EIP-7702 delegation for an EVM EOA account, upgrading it with smart account capabilities.
+   * The delegation allows the EVM EOA to be used as a smart account, which enables batched transactions and gas sponsorship via paymaster.
+   *
+   * @param {CreateEvmEip7702DelegationOptions} options - The delegation parameters (address and network required, enableSpendPermissions and idempotencyKey optional).
+   * @returns A promise that resolves to the delegation result including the delegation operation ID.
+   *
+   * @example
+   * ```ts
+   * const result = await cdp.evm.createEvmEip7702Delegation({
+   *   address: account.address,
+   *   network: "base-sepolia",
+   *   enableSpendPermissions: false,
+   * });
+   * console.log(result.delegationOperationId);
+   * ```
+   */
+  async createEvmEip7702Delegation(
+    options: CreateEvmEip7702DelegationOptions,
+  ): Promise<CreateEvmEip7702DelegationResult> {
+    Analytics.trackAction({
+      action: "create_eip7702_delegation",
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
+    try {
+      const { address, network, enableSpendPermissions, idempotencyKey } = options;
+      const body = {
+        network,
+        ...(enableSpendPermissions !== undefined && { enableSpendPermissions }),
+      };
+      return await CdpOpenApiClient.createEvmEip7702Delegation(address, body, idempotencyKey);
+    } catch (error) {
+      Analytics.trackError(error, "createEvmEip7702Delegation");
+      throw error;
+    }
+  }
 
-    return smartAccount;
+  /**
+   * Gets the EIP-7702 delegation operation status.
+   *
+   * @param {string} delegationOperationId - The delegation operation ID returned by createEvmEip7702Delegation.
+   * @returns A promise that resolves to the delegation operation status.
+   *
+   * @example
+   * ```ts
+   * const operation = await cdp.evm.getEvmEip7702DelegationOperationById(
+   *   "delegation-op-123",
+   * );
+   * console.log(operation.status); // "PENDING" | "SUBMITTED" | "COMPLETED" | "FAILED"
+   * ```
+   */
+  async getEvmEip7702DelegationOperationById(
+    delegationOperationId: string,
+  ): Promise<EvmEip7702DelegationOperation> {
+    Analytics.trackAction({
+      action: "get_eip7702_delegation_operation_by_id",
+    });
+
+    try {
+      return await CdpOpenApiClient.getEvmEip7702DelegationOperationById(delegationOperationId);
+    } catch (error) {
+      Analytics.trackError(error, "getEvmEip7702DelegationOperationById");
+      throw error;
+    }
+  }
+
+  /**
+   * Polls the EIP-7702 delegation operation status until the status is COMPLETED or a timeout occurs.
+   *
+   * @param {WaitForEvmEip7702DelegationOperationStatusOptions} options - Parameters for waiting, including delegationOperationId and optional wait configuration.
+   * @param {string} options.delegationOperationId - The delegation operation ID returned by createEvmEip7702Delegation.
+   * @param {WaitOptions} [options.waitOptions] - Optional parameters for the wait operation.
+   *
+   * @returns A promise that resolves to the delegation operation once it reaches COMPLETED.
+   *
+   * @example
+   * ```ts
+   * const operation = await cdp.evm.waitForEvmEip7702DelegationOperationStatus({
+   *   delegationOperationId: "delegation-op-123",
+   * });
+   * console.log(operation.status); // "COMPLETED"
+   * ```
+   */
+  async waitForEvmEip7702DelegationOperationStatus(
+    options: WaitForEvmEip7702DelegationOperationStatusOptions,
+  ): Promise<EvmEip7702DelegationOperation> {
+    Analytics.trackAction({
+      action: "wait_for_eip7702_delegation_operation_status",
+    });
+
+    try {
+      return await waitForEvmEip7702DelegationOperationStatus(CdpOpenApiClient, options);
+    } catch (error) {
+      Analytics.trackError(error, "waitForEvmEip7702DelegationOperationStatus");
+      throw error;
+    }
   }
 
   /**
@@ -1439,9 +1677,14 @@ export class EvmClient implements EvmClientInterface {
       action: "wait_for_user_operation",
     });
 
-    return waitForUserOperation(CdpOpenApiClient, {
-      ...options,
-    });
+    try {
+      return await waitForUserOperation(CdpOpenApiClient, {
+        ...options,
+      });
+    } catch (error) {
+      Analytics.trackError(error, "waitForUserOperation");
+      throw error;
+    }
   }
 
   /**
@@ -1466,8 +1709,6 @@ export class EvmClient implements EvmClientInterface {
       account: openApiAccount,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
     return account;
   }
 
@@ -1495,8 +1736,6 @@ export class EvmClient implements EvmClientInterface {
       account: openApiAccount,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(account);
-
     return account;
   }
 
@@ -1529,8 +1768,6 @@ export class EvmClient implements EvmClientInterface {
       owner: options.owner,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
-
     return smartAccount;
   }
 
@@ -1566,8 +1803,6 @@ Provided Owner Address: ${options.owner.address}\n`,
       owner: options.owner,
     });
 
-    Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
-
     return smartAccount;
   }
 }