@coinbase/cdp-sdk 1.26.0 → 1.28.0

package/accounts/evm/toEvmServerAccount.ts

@@ -32,6 +32,7 @@ import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapTransaction } from "../../actions/evm/swap/sendSwapTransaction.js";
 import { accountTransferStrategy } from "../../actions/evm/transfer/accountTransferStrategy.js";
 import { transfer } from "../../actions/evm/transfer/transfer.js";
+import { Analytics } from "../../analytics.js";
 
 import type { EvmServerAccount, NetworkOrRpcUrl } from "./types.js";
 import type {
@@ -71,6 +72,11 @@ export function toEvmServerAccount(
   const account: EvmServerAccount = {
     address: options.account.address as Address,
     async signMessage({ message }) {
+      Analytics.trackAction({
+        action: "sign_message",
+        accountType: "evm_server",
+      });
+
       const result = await apiClient.signEvmMessage(options.account.address, {
         message: message.toString(),
       });
@@ -78,6 +84,11 @@ export function toEvmServerAccount(
     },
 
     async sign(parameters: { hash: Hash }) {
+      Analytics.trackAction({
+        action: "sign",
+        accountType: "evm_server",
+      });
+
       const result = await apiClient.signEvmHash(options.account.address, {
         hash: parameters.hash,
       });
@@ -85,6 +96,11 @@ export function toEvmServerAccount(
     },
 
     async signTransaction(transaction: TransactionSerializable) {
+      Analytics.trackAction({
+        action: "sign_transaction",
+        accountType: "evm_server",
+      });
+
       const result = await apiClient.signEvmTransaction(options.account.address, {
         transaction: serializeTransaction(transaction),
       });
@@ -95,6 +111,11 @@ export function toEvmServerAccount(
       const typedData extends TypedData | Record<string, unknown>,
       primaryType extends keyof typedData | "EIP712Domain" = keyof typedData,
     >(parameters: TypedDataDefinition<typedData, primaryType>) {
+      Analytics.trackAction({
+        action: "sign_typed_data",
+        accountType: "evm_server",
+      });
+
       const { domain = {}, message, primaryType } = parameters as HashTypedDataParameters;
       const types = {
         EIP712Domain: getTypesForEIP712Domain({ domain }),
@@ -112,11 +133,27 @@ export function toEvmServerAccount(
       return result.signature as Hex;
     },
     async transfer(transferArgs): Promise<TransactionResult> {
+      Analytics.trackAction({
+        action: "transfer",
+        accountType: "evm_server",
+        properties: {
+          network: transferArgs.network,
+        },
+      });
+
       return transfer(apiClient, account, transferArgs, accountTransferStrategy);
     },
     async listTokenBalances(
       options: Omit<ListTokenBalancesOptions, "address">,
     ): Promise<ListTokenBalancesResult> {
+      Analytics.trackAction({
+        action: "list_token_balances",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return listTokenBalances(apiClient, {
         ...options,
         address: this.address,
@@ -125,24 +162,56 @@ export function toEvmServerAccount(
     async requestFaucet(
       options: Omit<RequestFaucetOptions, "address">,
     ): Promise<RequestFaucetResult> {
+      Analytics.trackAction({
+        action: "request_faucet",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return requestFaucet(apiClient, {
         ...options,
         address: this.address,
       });
     },
     async sendTransaction(options: Omit<SendTransactionOptions, "address">) {
+      Analytics.trackAction({
+        action: "send_transaction",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return sendTransaction(apiClient, {
         ...options,
         address: this.address,
       });
     },
     async quoteFund(options: Omit<QuoteFundOptions, "address">): Promise<Quote> {
+      Analytics.trackAction({
+        action: "quote_fund",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return quoteFund(apiClient, {
         ...options,
         address: this.address,
       });
     },
     async fund(options: Omit<FundOptions, "address">): Promise<FundOperationResult> {
+      Analytics.trackAction({
+        action: "fund",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return fund(apiClient, {
         ...options,
         address: this.address,
@@ -151,15 +220,36 @@ export function toEvmServerAccount(
     async waitForFundOperationReceipt(
       options: WaitForFundOperationOptions,
     ): Promise<WaitForFundOperationResult> {
+      Analytics.trackAction({
+        action: "wait_for_fund_operation_receipt",
+        accountType: "evm_server",
+      });
+
       return waitForFundOperationReceipt(apiClient, options);
     },
     async quoteSwap(options: AccountQuoteSwapOptions): Promise<AccountQuoteSwapResult> {
+      Analytics.trackAction({
+        action: "quote_swap",
+        accountType: "evm_server",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return createSwapQuote(apiClient, {
         ...options,
         taker: this.address,
       });
     },
     async swap(options: AccountSwapOptions): Promise<AccountSwapResult> {
+      Analytics.trackAction({
+        action: "swap",
+        accountType: "evm_server",
+        properties: {
+          network: "network" in options ? options.network : undefined,
+        },
+      });
+
       return sendSwapTransaction(apiClient, {
         ...options,
         address: this.address,
@@ -170,6 +260,14 @@ export function toEvmServerAccount(
     type: "evm-server",
     policies: options.account.policies,
     useNetwork: async <Network extends NetworkOrRpcUrl>(networkOrRpcUrl: Network) => {
+      Analytics.trackAction({
+        action: "use_network",
+        accountType: "evm_server",
+        properties: {
+          network: networkOrRpcUrl,
+        },
+      });
+
       return toNetworkScopedEvmServerAccount({
         account,
         network: networkOrRpcUrl,

package/accounts/evm/toEvmSmartAccount.ts

@@ -35,6 +35,7 @@ import {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
+import { Analytics } from "../../analytics.js";
 import {
   GetUserOperationOptions,
   SignTypedDataOptions,
@@ -85,11 +86,27 @@ export function toEvmSmartAccount(
     owners: [options.owner],
     policies: options.smartAccount.policies,
     async transfer(transferArgs): Promise<SendUserOperationReturnType> {
+      Analytics.trackAction({
+        action: "transfer",
+        accountType: "evm_smart",
+        properties: {
+          network: transferArgs.network,
+        },
+      });
+
       return transfer(apiClient, account, transferArgs, smartAccountTransferStrategy);
     },
     async listTokenBalances(
       options: Omit<ListTokenBalancesOptions, "address">,
     ): Promise<ListTokenBalancesResult> {
+      Analytics.trackAction({
+        action: "list_token_balances",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return listTokenBalances(apiClient, {
         ...options,
         address: this.address,
@@ -98,6 +115,14 @@ export function toEvmSmartAccount(
     async sendUserOperation(
       options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">,
     ): Promise<SendUserOperationReturnType> {
+      Analytics.trackAction({
+        action: "send_user_operation",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return sendUserOperation(apiClient, {
         ...options,
         smartAccount: account,
@@ -106,6 +131,11 @@ export function toEvmSmartAccount(
     async waitForUserOperation(
       options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
     ): Promise<WaitForUserOperationReturnType> {
+      Analytics.trackAction({
+        action: "wait_for_user_operation",
+        accountType: "evm_smart",
+      });
+
       return waitForUserOperation(apiClient, {
         ...options,
         smartAccountAddress: account.address,
@@ -114,6 +144,11 @@ export function toEvmSmartAccount(
     async getUserOperation(
       options: Omit<GetUserOperationOptions, "smartAccount">,
     ): Promise<UserOperation> {
+      Analytics.trackAction({
+        action: "get_user_operation",
+        accountType: "evm_smart",
+      });
+
       return getUserOperation(apiClient, {
         ...options,
         smartAccount: account,
@@ -122,18 +157,42 @@ export function toEvmSmartAccount(
     async requestFaucet(
       options: Omit<RequestFaucetOptions, "address">,
     ): Promise<RequestFaucetResult> {
+      Analytics.trackAction({
+        action: "request_faucet",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return requestFaucet(apiClient, {
         ...options,
         address: account.address,
       });
     },
     async quoteFund(options: Omit<QuoteFundOptions, "address">): Promise<Quote> {
+      Analytics.trackAction({
+        action: "quote_fund",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return quoteFund(apiClient, {
         ...options,
         address: this.address,
       });
     },
     async fund(options: Omit<FundOptions, "address">): Promise<FundOperationResult> {
+      Analytics.trackAction({
+        action: "fund",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return fund(apiClient, {
         ...options,
         address: this.address,
@@ -142,9 +201,22 @@ export function toEvmSmartAccount(
     async waitForFundOperationReceipt(
       options: WaitForFundOperationOptions,
     ): Promise<WaitForFundOperationResult> {
+      Analytics.trackAction({
+        action: "wait_for_fund_operation_receipt",
+        accountType: "evm_smart",
+      });
+
       return waitForFundOperationReceipt(apiClient, options);
     },
     async quoteSwap(options: SmartAccountQuoteSwapOptions): Promise<SmartAccountQuoteSwapResult> {
+      Analytics.trackAction({
+        action: "quote_swap",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return createSwapQuote(apiClient, {
         ...options,
         taker: this.address, // Always use smart account's address as taker
@@ -153,6 +225,14 @@ export function toEvmSmartAccount(
       });
     },
     async swap(options: SmartAccountSwapOptions): Promise<SmartAccountSwapResult> {
+      Analytics.trackAction({
+        action: "swap",
+        accountType: "evm_smart",
+        properties: {
+          network: "network" in options ? options.network : undefined,
+        },
+      });
+
       return sendSwapOperation(apiClient, {
         ...options,
         smartAccount: account,
@@ -163,6 +243,14 @@ export function toEvmSmartAccount(
     async signTypedData(
       options: Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks },
     ): Promise<Hex> {
+      Analytics.trackAction({
+        action: "sign_typed_data",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       const result = await signAndWrapTypedDataForSmartAccount(apiClient, {
         chainId: BigInt(resolveNetworkToChain(options.network).id),
         smartAccount: account,
@@ -174,6 +262,14 @@ export function toEvmSmartAccount(
     name: options.smartAccount.name,
     type: "evm-smart",
     useNetwork: async <Network extends KnownEvmNetworks>(network: Network) => {
+      Analytics.trackAction({
+        action: "use_network",
+        accountType: "evm_smart",
+        properties: {
+          network,
+        },
+      });
+
       return toNetworkScopedEvmSmartAccount(apiClient, {
         smartAccount: account,
         owner: options.owner,

package/accounts/evm/toNetworkScopedEvmServerAccount.ts

@@ -5,6 +5,7 @@ import { mapChainToNetwork } from "./chainToNetworkMapper.js";
 import { isMethodSupportedOnNetwork } from "./networkCapabilities.js";
 import { resolveViemClients } from "./resolveViemClients.js";
 import { transferWithViem } from "../../actions/evm/transfer/transferWithViem.js";
+import { Analytics } from "../../analytics.js";
 
 import type { EvmServerAccount, NetworkScopedEvmServerAccount } from "./types.js";
 import type { FundOptions } from "../../actions/evm/fund/fund.js";
@@ -51,6 +52,12 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     account: options.account,
   });
 
+  /*
+   * Determine the actual network name from the resolved chain
+   * This handles cases where options.network is an RPC URL
+   */
+  const resolvedNetworkName = mapChainToNetwork(chain) ?? options.network;
+
   const shouldUseApiForSends =
     chain.id === base.id ||
     chain.id === baseSepolia.id ||
@@ -74,6 +81,14 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
           network: mapChainToNetwork(chain) as SendEvmTransactionBodyNetwork,
         });
       } else {
+        Analytics.trackAction({
+          action: "send_transaction",
+          accountType: "evm_server",
+          properties: {
+            network: options.network,
+          },
+        });
+
         const hash = await walletClient.sendTransaction(
           txOpts.transaction as TransactionRequestEIP1559,
         );
@@ -87,12 +102,25 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
           network: mapChainToNetwork(chain) as SendEvmTransactionBodyNetwork,
         });
       } else {
+        Analytics.trackAction({
+          action: "transfer",
+          accountType: "evm_server",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return transferWithViem(walletClient, account, transferArgs);
       }
     },
     waitForTransactionReceipt: async (
       waitOptions: WaitForTransactionReceiptParameters | TransactionResult,
     ) => {
+      Analytics.trackAction({
+        action: "wait_for_transaction_receipt",
+        accountType: "evm_server",
+      });
+
       if ("transactionHash" in waitOptions) {
         return publicClient.waitForTransactionReceipt({
           hash: waitOptions.transactionHash,
@@ -102,7 +130,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     },
   } as NetworkScopedEvmServerAccount<Network>;
 
-  if (isMethodSupportedOnNetwork("listTokenBalances", options.network)) {
+  if (isMethodSupportedOnNetwork("listTokenBalances", resolvedNetworkName)) {
     Object.assign(account, {
       listTokenBalances: async (
         listTokenBalancesOptions: Omit<ListTokenBalancesOptions, "address" | "network">,
@@ -115,7 +143,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("requestFaucet", options.network)) {
+  if (isMethodSupportedOnNetwork("requestFaucet", resolvedNetworkName)) {
     Object.assign(account, {
       requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
         return options.account.requestFaucet({
@@ -126,7 +154,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("quoteFund", options.network)) {
+  if (isMethodSupportedOnNetwork("quoteFund", resolvedNetworkName)) {
     Object.assign(account, {
       quoteFund: async (quoteFundOptions: Omit<QuoteFundOptions, "address">) => {
         return options.account.quoteFund({
@@ -136,7 +164,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("fund", options.network)) {
+  if (isMethodSupportedOnNetwork("fund", resolvedNetworkName)) {
     Object.assign(account, {
       fund: async (fundOptions: Omit<FundOptions, "address">) => {
         return options.account.fund({
@@ -149,7 +177,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("quoteSwap", options.network)) {
+  if (isMethodSupportedOnNetwork("quoteSwap", resolvedNetworkName)) {
     Object.assign(account, {
       quoteSwap: async (quoteSwapOptions: AccountQuoteSwapOptions) => {
         return options.account.quoteSwap(quoteSwapOptions);
@@ -157,7 +185,7 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("swap", options.network)) {
+  if (isMethodSupportedOnNetwork("swap", resolvedNetworkName)) {
     Object.assign(account, {
       swap: async (swapOptions: AccountSwapOptions) => {
         return options.account.swap(swapOptions);

package/accounts/evm/toNetworkScopedEvmSmartAccount.ts

@@ -12,6 +12,7 @@ import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
 import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
 import { transfer } from "../../actions/evm/transfer/transfer.js";
 import { waitForUserOperation } from "../../actions/evm/waitForUserOperation.js";
+import { Analytics } from "../../analytics.js";
 
 import type {
   EvmAccount,
@@ -84,6 +85,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
     sendUserOperation: async (
       userOpOptions: Omit<SendUserOperationOptions<unknown[]>, "smartAccount" | "network">,
     ) => {
+      Analytics.trackAction({
+        action: "send_user_operation",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return sendUserOperation(apiClient, {
         ...userOpOptions,
         smartAccount: options.smartAccount,
@@ -94,12 +103,22 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
     waitForUserOperation: async (
       waitOptions: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
     ) => {
+      Analytics.trackAction({
+        action: "wait_for_user_operation",
+        accountType: "evm_smart",
+      });
+
       return waitForUserOperation(apiClient, {
         ...waitOptions,
         smartAccountAddress: options.smartAccount.address,
       });
     },
     getUserOperation: async (getOptions: Omit<GetUserOperationOptions, "smartAccount">) => {
+      Analytics.trackAction({
+        action: "get_user_operation",
+        accountType: "evm_smart",
+      });
+
       return getUserOperation(apiClient, {
         ...getOptions,
         smartAccount: options.smartAccount,
@@ -110,6 +129,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("transfer", options.network)) {
     Object.assign(account, {
       transfer: async (transferOptions: Omit<SmartAccountTransferOptions, "network">) => {
+        Analytics.trackAction({
+          action: "transfer",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return transfer(
           apiClient,
           options.smartAccount,
@@ -129,6 +156,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
       listTokenBalances: async (
         listOptions: Omit<ListTokenBalancesOptions, "address" | "network">,
       ) => {
+        Analytics.trackAction({
+          action: "list_token_balances",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return listTokenBalances(apiClient, {
           ...listOptions,
           address: options.smartAccount.address,
@@ -141,6 +176,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("requestFaucet", options.network)) {
     Object.assign(account, {
       requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
+        Analytics.trackAction({
+          action: "request_faucet",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return requestFaucet(apiClient, {
           ...faucetOptions,
           address: options.smartAccount.address,
@@ -153,6 +196,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("quoteFund", options.network)) {
     Object.assign(account, {
       quoteFund: async (quoteOptions: Omit<QuoteFundOptions, "address">) => {
+        Analytics.trackAction({
+          action: "quote_fund",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return quoteFund(apiClient, {
           ...quoteOptions,
           address: options.smartAccount.address,
@@ -164,6 +215,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("fund", options.network)) {
     Object.assign(account, {
       fund: async (fundOptions: Omit<FundOptions, "address">) => {
+        Analytics.trackAction({
+          action: "fund",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return fund(apiClient, {
           ...fundOptions,
           address: options.smartAccount.address,
@@ -178,6 +237,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("quoteSwap", options.network)) {
     Object.assign(account, {
       quoteSwap: async (quoteSwapOptions: SmartAccountQuoteSwapOptions) => {
+        Analytics.trackAction({
+          action: "quote_swap",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return createSwapQuote(apiClient, {
           ...quoteSwapOptions,
           taker: options.smartAccount.address,
@@ -192,6 +259,14 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
   if (isMethodSupportedOnNetwork("swap", options.network)) {
     Object.assign(account, {
       swap: async (swapOptions: SmartAccountSwapOptions) => {
+        Analytics.trackAction({
+          action: "swap",
+          accountType: "evm_smart",
+          properties: {
+            network: options.network,
+          },
+        });
+
         return sendSwapOperation(apiClient, {
           ...swapOptions,
           smartAccount: options.smartAccount,

package/accounts/solana/toSolanaAccount.ts

@@ -3,6 +3,7 @@ import { requestFaucet } from "../../actions/solana/requestFaucet.js";
 import { signMessage } from "../../actions/solana/signMessage.js";
 import { signTransaction } from "../../actions/solana/signTransaction.js";
 import { transfer, type TransferOptions } from "../../actions/solana/transfer.js";
+import { Analytics } from "../../analytics.js";
 import {
   RequestFaucetOptions,
   SignatureResult,
@@ -35,12 +36,22 @@ export function toSolanaAccount(
     address: options.account.address,
     name: options.account.name,
     async requestFaucet(options: Omit<RequestFaucetOptions, "address">): Promise<SignatureResult> {
+      Analytics.trackAction({
+        action: "request_faucet",
+        accountType: "solana",
+      });
+
       return requestFaucet(apiClient, {
         ...options,
         address: account.address,
       });
     },
     async signMessage(options: Omit<SignMessageOptions, "address">): Promise<SignatureResult> {
+      Analytics.trackAction({
+        action: "sign_message",
+        accountType: "solana",
+      });
+
       return signMessage(apiClient, {
         ...options,
         address: account.address,
@@ -49,6 +60,11 @@ export function toSolanaAccount(
     async signTransaction(
       options: Omit<SignTransactionOptions, "address">,
     ): Promise<SignatureResult> {
+      Analytics.trackAction({
+        action: "sign_transaction",
+        accountType: "solana",
+      });
+
       return signTransaction(apiClient, {
         ...options,
         address: account.address,
@@ -56,6 +72,14 @@ export function toSolanaAccount(
     },
     policies: options.account.policies,
     async transfer(options: Omit<TransferOptions, "from">): Promise<SignatureResult> {
+      Analytics.trackAction({
+        action: "transfer",
+        accountType: "solana",
+        properties: {
+          network: options.network,
+        },
+      });
+
       return transfer(apiClient, {
         ...options,
         from: account.address,