@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/_esm/client/evm/evm.js

@@ -14,6 +14,7 @@ import { sendUserOperation, } from "../../actions/evm/sendUserOperation.js";
 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, } from "../../actions/evm/waitForUserOperation.js";
 import { Analytics } from "../../analytics.js";
 import { ImportAccountPublicRSAKey } from "../../constants.js";
@@ -65,7 +66,13 @@ export class EvmClient {
             action: "create_account",
             accountType: "evm_server",
         });
-        return this._createAccountInternal(options);
+        try {
+            return await this._createAccountInternal(options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "createAccount");
+            throw error;
+        }
     }
     /**
      * Imports a CDP EVM account from an external source.
@@ -114,14 +121,14 @@ export class EvmClient {
             action: "import_account",
             accountType: "evm_server",
         });
-        const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
-        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");
-        }
         try {
+            const encryptionPublicKey = options.encryptionPublicKey || ImportAccountPublicRSAKey;
+            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");
+            }
             const privateKeyBytes = Buffer.from(privateKeyHex, "hex");
             const encryptedPrivateKey = publicEncrypt({
                 key: encryptionPublicKey,
@@ -135,10 +142,12 @@ export class EvmClient {
             const account = toEvmServerAccount(CdpOpenApiClient, {
                 account: openApiAccount,
             });
-            Analytics.wrapObjectMethodsWithErrorTracking(account);
             return account;
         }
         catch (error) {
+            if (!(error instanceof UserInputValidationError)) {
+                Analytics.trackError(error, "importAccount");
+            }
             if (error instanceof APIError) {
                 throw error;
             }
@@ -175,21 +184,29 @@ export class EvmClient {
             action: "export_account",
             accountType: "evm_server",
         });
-        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);
+        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);
+                }
+                throw new UserInputValidationError("Either address or name must be provided");
+            })();
+            return decryptWithPrivateKey(privateKey, encryptedPrivateKey);
+        }
+        catch (error) {
+            if (!(error instanceof UserInputValidationError)) {
+                Analytics.trackError(error, "exportAccount");
             }
-            throw new UserInputValidationError("Either address or name must be provided");
-        })();
-        return decryptWithPrivateKey(privateKey, encryptedPrivateKey);
+            throw error;
+        }
     }
     /**
      * Creates a new CDP EVM smart account.
@@ -241,7 +258,13 @@ export class EvmClient {
             action: "create_smart_account",
             accountType: "evm_smart",
         });
-        return this._createSmartAccountInternal(options);
+        try {
+            return await this._createSmartAccountInternal(options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "createSmartAccount");
+            throw error;
+        }
     }
     /**
      * Creates a spend permission for a smart account.
@@ -264,29 +287,35 @@ export class EvmClient {
         Analytics.trackAction({
             action: "create_spend_permission",
         });
-        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);
-        return {
-            network: userOperation.network,
-            userOpHash: userOperation.userOpHash,
-            status: userOperation.status,
-            calls: userOperation.calls.map(call => ({
-                to: call.to,
-                value: BigInt(call.value),
-                data: call.data,
-            })),
-        };
+        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);
+            return {
+                network: userOperation.network,
+                userOpHash: userOperation.userOpHash,
+                status: userOperation.status,
+                calls: userOperation.calls.map(call => ({
+                    to: call.to,
+                    value: BigInt(call.value),
+                    data: call.data,
+                })),
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "createSpendPermission");
+            throw error;
+        }
     }
     /**
      * Revokes a spend permission for a smart account.
@@ -312,21 +341,27 @@ export class EvmClient {
         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,
-            status: userOperation.status,
-            calls: userOperation.calls.map(call => ({
-                to: call.to,
-                value: BigInt(call.value),
-                data: call.data,
-            })),
-        };
+        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,
+                status: userOperation.status,
+                calls: userOperation.calls.map(call => ({
+                    to: call.to,
+                    value: BigInt(call.value),
+                    data: call.data,
+                })),
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "revokeSpendPermission");
+            throw error;
+        }
     }
     /**
      * Gets a CDP EVM account.
@@ -358,7 +393,13 @@ export class EvmClient {
             action: "get_account",
             accountType: "evm_server",
         });
-        return this._getAccountInternal(options);
+        try {
+            return await this._getAccountInternal(options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "getAccount");
+            throw error;
+        }
     }
     /**
      * Gets a CDP EVM smart account.
@@ -386,7 +427,13 @@ export class EvmClient {
         Analytics.trackAction({
             action: "get_smart_account",
         });
-        return this._getSmartAccountInternal(options);
+        try {
+            return await this._getSmartAccountInternal(options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "getSmartAccount");
+            throw error;
+        }
     }
     /**
      * Gets a CDP EVM account, or creates one if it doesn't exist.
@@ -409,27 +456,33 @@ export class EvmClient {
             accountType: "evm_server",
         });
         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;
                     }
-                    throw error;
+                    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;
             }
+        }
+        catch (error) {
+            Analytics.trackError(error, "getOrCreateAccount");
             throw error;
         }
     }
@@ -458,27 +511,33 @@ export class EvmClient {
             accountType: "evm_smart",
         });
         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;
                     }
-                    throw error;
+                    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;
             }
+        }
+        catch (error) {
+            Analytics.trackError(error, "getOrCreateSmartAccount");
             throw error;
         }
     }
@@ -507,7 +566,13 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        return getSwapPrice(CdpOpenApiClient, options);
+        try {
+            return await getSwapPrice(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "getSwapPrice");
+            throw error;
+        }
     }
     /**
      * Creates a quote for a swap between two tokens on an EVM network.
@@ -534,7 +599,13 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        return createSwapQuote(CdpOpenApiClient, options);
+        try {
+            return await createSwapQuote(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "createSwapQuote");
+            throw error;
+        }
     }
     /**
      * Gets a user operation for a smart account by user operation hash.
@@ -557,7 +628,13 @@ export class EvmClient {
         Analytics.trackAction({
             action: "get_user_operation",
         });
-        return getUserOperation(CdpOpenApiClient, options);
+        try {
+            return await getUserOperation(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "getUserOperation");
+            throw error;
+        }
     }
     /**
      * Lists CDP EVM accounts.
@@ -588,20 +665,25 @@ export class EvmClient {
             action: "list_accounts",
             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,
-                });
-                Analytics.wrapObjectMethodsWithErrorTracking(evmAccount);
-                return evmAccount;
-            }),
-            nextPageToken: ethAccounts.nextPageToken,
-        };
+        try {
+            const ethAccounts = await CdpOpenApiClient.listEvmAccounts({
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+            });
+            return {
+                accounts: ethAccounts.accounts.map(account => {
+                    const evmAccount = toEvmServerAccount(CdpOpenApiClient, {
+                        account,
+                    });
+                    return evmAccount;
+                }),
+                nextPageToken: ethAccounts.nextPageToken,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "listAccounts");
+            throw error;
+        }
     }
     /**
      * Lists CDP EVM token balances.
@@ -644,7 +726,13 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        return listTokenBalances(CdpOpenApiClient, options);
+        try {
+            return await listTokenBalances(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "listTokenBalances");
+            throw error;
+        }
     }
     /**
      * Lists CDP EVM smart accounts.
@@ -674,19 +762,25 @@ export class EvmClient {
         Analytics.trackAction({
             action: "list_smart_accounts",
         });
-        const smartAccounts = await CdpOpenApiClient.listEvmSmartAccounts({
-            pageSize: options.pageSize,
-            pageToken: options.pageToken,
-        });
-        return {
-            accounts: smartAccounts.accounts.map(account => ({
-                address: account.address,
-                owners: [account.owners[0]],
-                type: "evm-smart",
-                policies: account.policies,
-            })),
-            nextPageToken: smartAccounts.nextPageToken,
-        };
+        try {
+            const smartAccounts = await CdpOpenApiClient.listEvmSmartAccounts({
+                pageSize: options.pageSize,
+                pageToken: options.pageToken,
+            });
+            return {
+                accounts: smartAccounts.accounts.map(account => ({
+                    address: account.address,
+                    owners: [account.owners[0]],
+                    type: "evm-smart",
+                    policies: account.policies,
+                })),
+                nextPageToken: smartAccounts.nextPageToken,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "listSmartAccounts");
+            throw error;
+        }
     }
     /**
      * Lists the spend permissions for a smart account.
@@ -702,7 +796,13 @@ export class EvmClient {
         Analytics.trackAction({
             action: "list_spend_permissions",
         });
-        return listSpendPermissions(CdpOpenApiClient, options);
+        try {
+            return await listSpendPermissions(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "listSpendPermissions");
+            throw error;
+        }
     }
     /**
      * Prepares a user operation for a smart account.
@@ -737,27 +837,33 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        const userOp = await CdpOpenApiClient.prepareUserOperation(options.smartAccount.address, {
-            network: options.network,
-            calls: options.calls.map(call => ({
-                to: call.to,
-                value: call.value.toString(),
-                data: call.data,
-                overrideGasLimit: call.overrideGasLimit,
-            })),
-            paymasterUrl: options.paymasterUrl,
-            dataSuffix: options.dataSuffix,
-        });
-        return {
-            network: userOp.network,
-            userOpHash: userOp.userOpHash,
-            status: userOp.status,
-            calls: userOp.calls.map(call => ({
-                to: call.to,
-                value: BigInt(call.value),
-                data: call.data,
-            })),
-        };
+        try {
+            const userOp = await CdpOpenApiClient.prepareUserOperation(options.smartAccount.address, {
+                network: options.network,
+                calls: options.calls.map(call => ({
+                    to: call.to,
+                    value: call.value.toString(),
+                    data: call.data,
+                    overrideGasLimit: call.overrideGasLimit,
+                })),
+                paymasterUrl: options.paymasterUrl,
+                dataSuffix: options.dataSuffix,
+            });
+            return {
+                network: userOp.network,
+                userOpHash: userOp.userOpHash,
+                status: userOp.status,
+                calls: userOp.calls.map(call => ({
+                    to: call.to,
+                    value: BigInt(call.value),
+                    data: call.data,
+                })),
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "prepareUserOperation");
+            throw error;
+        }
     }
     /**
      * Prepares and sends a user operation for a smart account.
@@ -792,20 +898,26 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        const userOp = await CdpOpenApiClient.prepareAndSendUserOperation(options.smartAccount.address, {
-            network: options.network,
-            calls: options.calls.map(call => ({
-                to: call.to,
-                value: call.value.toString(),
-                data: call.data,
-            })),
-            paymasterUrl: options.paymasterUrl,
-        }, options.idempotencyKey);
-        return {
-            smartAccountAddress: options.smartAccount.address,
-            userOpHash: userOp.userOpHash,
-            status: userOp.status,
-        };
+        try {
+            const userOp = await CdpOpenApiClient.prepareAndSendUserOperation(options.smartAccount.address, {
+                network: options.network,
+                calls: options.calls.map(call => ({
+                    to: call.to,
+                    value: call.value.toString(),
+                    data: call.data,
+                })),
+                paymasterUrl: options.paymasterUrl,
+            }, options.idempotencyKey);
+            return {
+                smartAccountAddress: options.smartAccount.address,
+                userOpHash: userOp.userOpHash,
+                status: userOp.status,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "prepareAndSendUserOperation");
+            throw error;
+        }
     }
     /**
      * Requests funds from an EVM faucet.
@@ -834,7 +946,13 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        return requestFaucet(CdpOpenApiClient, options);
+        try {
+            return await requestFaucet(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "requestFaucet");
+            throw error;
+        }
     }
     /**
      * Signs an EVM transaction and sends it to the specified network using the Coinbase API.
@@ -889,7 +1007,13 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        return sendTransaction(CdpOpenApiClient, options);
+        try {
+            return await sendTransaction(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "sendTransaction");
+            throw error;
+        }
     }
     /**
      * Sends a user operation.
@@ -926,14 +1050,20 @@ export class EvmClient {
                 network: options.network,
             },
         });
-        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;
+        }
     }
     /**
      * Signs an EVM hash.
@@ -960,12 +1090,18 @@ export class EvmClient {
         Analytics.trackAction({
             action: "sign_hash",
         });
-        const signature = await CdpOpenApiClient.signEvmHash(options.address, {
-            hash: options.hash,
-        }, options.idempotencyKey);
-        return {
-            signature: signature.signature,
-        };
+        try {
+            const signature = await CdpOpenApiClient.signEvmHash(options.address, {
+                hash: options.hash,
+            }, options.idempotencyKey);
+            return {
+                signature: signature.signature,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "signHash");
+            throw error;
+        }
     }
     /**
      * Signs an EIP-191 message.
@@ -992,12 +1128,18 @@ export class EvmClient {
         Analytics.trackAction({
             action: "sign_message",
         });
-        const signature = await CdpOpenApiClient.signEvmMessage(options.address, {
-            message: options.message,
-        }, options.idempotencyKey);
-        return {
-            signature: signature.signature,
-        };
+        try {
+            const signature = await CdpOpenApiClient.signEvmMessage(options.address, {
+                message: options.message,
+            }, options.idempotencyKey);
+            return {
+                signature: signature.signature,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "signMessage");
+            throw error;
+        }
     }
     /**
      * Signs an EIP-712 message.
@@ -1048,21 +1190,27 @@ export class EvmClient {
         Analytics.trackAction({
             action: "sign_typed_data",
         });
-        const { domain, message, primaryType } = options;
-        const types = {
-            EIP712Domain: getTypesForEIP712Domain({ domain }),
-            ...options.types,
-        };
-        const openApiMessage = {
-            domain,
-            types,
-            primaryType,
-            message,
-        };
-        const signature = await CdpOpenApiClient.signEvmTypedData(options.address, openApiMessage, options.idempotencyKey);
-        return {
-            signature: signature.signature,
-        };
+        try {
+            const { domain, message, primaryType } = options;
+            const types = {
+                EIP712Domain: getTypesForEIP712Domain({ domain }),
+                ...options.types,
+            };
+            const openApiMessage = {
+                domain,
+                types,
+                primaryType,
+                message,
+            };
+            const signature = await CdpOpenApiClient.signEvmTypedData(options.address, openApiMessage, options.idempotencyKey);
+            return {
+                signature: signature.signature,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "signTypedData");
+            throw error;
+        }
     }
     /**
      * Signs an EVM transaction.
@@ -1098,12 +1246,18 @@ export class EvmClient {
         Analytics.trackAction({
             action: "sign_transaction",
         });
-        const signature = await CdpOpenApiClient.signEvmTransaction(options.address, {
-            transaction: options.transaction,
-        }, options.idempotencyKey);
-        return {
-            signature: signature.signedTransaction,
-        };
+        try {
+            const signature = await CdpOpenApiClient.signEvmTransaction(options.address, {
+                transaction: options.transaction,
+            }, options.idempotencyKey);
+            return {
+                signature: signature.signedTransaction,
+            };
+        }
+        catch (error) {
+            Analytics.trackError(error, "signTransaction");
+            throw error;
+        }
     }
     /**
      * Updates a CDP EVM account.
@@ -1150,12 +1304,17 @@ export class EvmClient {
         Analytics.trackAction({
             action: "update_account",
         });
-        const openApiAccount = await CdpOpenApiClient.updateEvmAccount(options.address, options.update, options.idempotencyKey);
-        const account = toEvmServerAccount(CdpOpenApiClient, {
-            account: openApiAccount,
-        });
-        Analytics.wrapObjectMethodsWithErrorTracking(account);
-        return account;
+        try {
+            const openApiAccount = await CdpOpenApiClient.updateEvmAccount(options.address, options.update, options.idempotencyKey);
+            const account = toEvmServerAccount(CdpOpenApiClient, {
+                account: openApiAccount,
+            });
+            return account;
+        }
+        catch (error) {
+            Analytics.trackError(error, "updateAccount");
+            throw error;
+        }
     }
     /**
      * Updates a CDP EVM smart account.
@@ -1173,13 +1332,107 @@ export class EvmClient {
         Analytics.trackAction({
             action: "update_smart_account",
         });
-        const openApiSmartAccount = await CdpOpenApiClient.updateEvmSmartAccount(options.address, options.update, options.idempotencyKey);
-        const smartAccount = toEvmSmartAccount(CdpOpenApiClient, {
-            smartAccount: openApiSmartAccount,
-            owner: options.owner,
+        try {
+            const openApiSmartAccount = await CdpOpenApiClient.updateEvmSmartAccount(options.address, options.update, options.idempotencyKey);
+            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) {
+        Analytics.trackAction({
+            action: "create_eip7702_delegation",
         });
-        Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
-        return 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;
+        }
+    }
+    /**
+     * 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) {
+        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) {
+        Analytics.trackAction({
+            action: "wait_for_eip7702_delegation_operation_status",
+        });
+        try {
+            return await waitForEvmEip7702DelegationOperationStatus(CdpOpenApiClient, options);
+        }
+        catch (error) {
+            Analytics.trackError(error, "waitForEvmEip7702DelegationOperationStatus");
+            throw error;
+        }
     }
     /**
      * Waits for a user operation to complete or fail.
@@ -1217,9 +1470,15 @@ export class EvmClient {
         Analytics.trackAction({
             action: "wait_for_user_operation",
         });
-        return waitForUserOperation(CdpOpenApiClient, {
-            ...options,
-        });
+        try {
+            return await waitForUserOperation(CdpOpenApiClient, {
+                ...options,
+            });
+        }
+        catch (error) {
+            Analytics.trackError(error, "waitForUserOperation");
+            throw error;
+        }
     }
     /**
      * Internal method to create an account without tracking analytics.
@@ -1236,7 +1495,6 @@ export class EvmClient {
         const account = toEvmServerAccount(CdpOpenApiClient, {
             account: openApiAccount,
         });
-        Analytics.wrapObjectMethodsWithErrorTracking(account);
         return account;
     }
     /**
@@ -1259,7 +1517,6 @@ export class EvmClient {
         const account = toEvmServerAccount(CdpOpenApiClient, {
             account: openApiAccount,
         });
-        Analytics.wrapObjectMethodsWithErrorTracking(account);
         return account;
     }
     /**
@@ -1282,7 +1539,6 @@ export class EvmClient {
             smartAccount: openApiSmartAccount,
             owner: options.owner,
         });
-        Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
         return smartAccount;
     }
     /**
@@ -1313,7 +1569,6 @@ Provided Owner Address: ${options.owner.address}\n`);
             smartAccount: openApiSmartAccount,
             owner: options.owner,
         });
-        Analytics.wrapObjectMethodsWithErrorTracking(smartAccount);
         return smartAccount;
     }
 }