@coinbase/cdp-sdk 1.25.0 → 1.27.0

package/accounts/evm/toEvmSmartAccount.ts

@@ -1,3 +1,4 @@
+import { resolveNetworkToChain } from "./networkToChainResolver.js";
 import { toNetworkScopedEvmSmartAccount } from "./toNetworkScopedEvmSmartAccount.js";
 import { fund, FundOptions } from "../../actions/evm/fund/fund.js";
 import { Quote } from "../../actions/evm/fund/Quote.js";
@@ -24,6 +25,7 @@ import {
   type SendUserOperationReturnType,
   sendUserOperation,
 } from "../../actions/evm/sendUserOperation.js";
+import { signAndWrapTypedDataForSmartAccount } from "../../actions/evm/signAndWrapTypedDataForSmartAccount.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
 import { smartAccountTransferStrategy } from "../../actions/evm/transfer/smartAccountTransferStrategy.js";
@@ -33,7 +35,12 @@ import {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
-import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { Analytics } from "../../analytics.js";
+import {
+  GetUserOperationOptions,
+  SignTypedDataOptions,
+  UserOperation,
+} from "../../client/evm/evm.types.js";
 
 import type { EvmAccount, EvmSmartAccount, KnownEvmNetworks } from "./types.js";
 import type {
@@ -46,7 +53,7 @@ import type {
   CdpOpenApiClientType,
   EvmSmartAccount as EvmSmartAccountModel,
 } from "../../openapi-client/index.js";
-import type { Address } from "../../types/misc.js";
+import type { Address, Hex } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmSmartAccount and owner to a EvmSmartAccount
@@ -79,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,
@@ -92,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,
@@ -100,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,
@@ -108,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,
@@ -116,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,
@@ -136,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
@@ -147,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,
@@ -154,10 +240,36 @@ export function toEvmSmartAccount(
         signerAddress: this.owners[0].address, // Always use owner's address as signer
       });
     },
+    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,
+        typedData: options,
+      });
+      return result.signature;
+    },
 
     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";
@@ -74,6 +75,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 +96,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,
@@ -149,14 +171,6 @@ export async function toNetworkScopedEvmServerAccount<Network extends string>(
     });
   }
 
-  if (isMethodSupportedOnNetwork("transfer", options.network)) {
-    Object.assign(account, {
-      transfer: async (transferOptions: TransferOptions) => {
-        return options.account.transfer(transferOptions);
-      },
-    });
-  }
-
   if (isMethodSupportedOnNetwork("quoteSwap", options.network)) {
     Object.assign(account, {
       quoteSwap: async (quoteSwapOptions: AccountQuoteSwapOptions) => {

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/evm/types.ts

@@ -132,7 +132,7 @@ export type EvmServerAccount = Prettify<
     }
 >;
 
-type EvmSmartAccountProperties = {
+export type EvmSmartAccountProperties = {
   /** The smart account's address. */
   address: Address;
   /** The name of the smart account. */
@@ -173,7 +173,7 @@ type DistributedOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : ne
 /**
  * Helper type for network-specific smart account actions
  */
-type NetworkSpecificSmartAccountActions<Network extends string> = Prettify<
+export type NetworkSpecificSmartAccountActions<Network extends string> = Prettify<
   // Always include sendUserOperation, waitForUserOperation and getUserOperation
   {
     sendUserOperation: <const callData extends unknown[]>(
@@ -261,7 +261,7 @@ type EmptyObject = {};
 /**
  * Conditional account actions based on network
  */
-type NetworkSpecificAccountActions<Network extends string> = Prettify<
+export type NetworkSpecificAccountActions<Network extends string> = Prettify<
   // Always include sendTransaction, transfer and waitForTransactionReceipt
   {
     sendTransaction: (

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,

package/actions/evm/fund/fund.ts

@@ -1,6 +1,7 @@
 import { formatUnits } from "viem";
 
 import { FundOperationResult } from "./types.js";
+import { UserInputValidationError } from "../../../errors.js";
 import {
   CreatePaymentTransferQuoteBodySourceType,
   CreatePaymentTransferQuoteBodyTargetType,
@@ -42,8 +43,8 @@ export async function fund(
     throw new Error("No card found to fund account");
   }
 
-  if (options.token.toLowerCase() !== "eth" && options.token.toLowerCase() !== "usdc") {
-    throw new Error("Invalid currency, must be eth or usdc");
+  if (options.token !== "eth" && options.token !== "usdc") {
+    throw new UserInputValidationError("Invalid token, must be eth or usdc");
   }
 
   const decimals = options.token === "eth" ? 18 : 6;

package/actions/evm/fund/quoteFund.ts

@@ -1,6 +1,7 @@
 import { formatUnits } from "viem";
 
 import { Quote } from "./Quote.js";
+import { UserInputValidationError } from "../../../errors.js";
 import {
   CreatePaymentTransferQuoteBodySourceType,
   CreatePaymentTransferQuoteBodyTargetType,
@@ -42,8 +43,8 @@ export async function quoteFund(
     throw new Error("No card found to fund account");
   }
 
-  if (options.token.toLowerCase() !== "eth" && options.token.toLowerCase() !== "usdc") {
-    throw new Error("Invalid currency, must be eth or usdc");
+  if (options.token !== "eth" && options.token !== "usdc") {
+    throw new UserInputValidationError("Invalid token, must be eth or usdc");
   }
 
   const decimals = options.token === "eth" ? 18 : 6;

package/actions/evm/types.ts

@@ -7,7 +7,12 @@ import {
   WaitForFundOperationResult,
 } from "./fund/waitForFundOperationReceipt.js";
 import { SendUserOperationOptions, SendUserOperationReturnType } from "./sendUserOperation.js";
-import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { KnownEvmNetworks } from "../../accounts/evm/types.js";
+import {
+  GetUserOperationOptions,
+  SignTypedDataOptions,
+  UserOperation,
+} from "../../client/evm/evm.types.js";
 import { Hex } from "../../types/misc.js";
 
 import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
@@ -29,7 +34,7 @@ import type {
   WaitForUserOperationReturnType,
 } from "./waitForUserOperation.js";
 
-type Actions = {
+export type Actions = {
   /**
    * List the token balances of an account.
    *
@@ -601,4 +606,38 @@ export type SmartAccountActions = Actions & {
    * ```
    */
   swap: (options: SmartAccountSwapOptions) => Promise<SmartAccountSwapResult>;
+
+  /**
+   * Signs a typed data message.
+   *
+   * @param {SignTypedDataOptions} options - Configuration options for signing the typed data.
+   * @param {string} options.network - The network to sign the typed data on
+   * @param {string} options.typedData - The typed data to sign
+   *
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * const signature = await smartAccount.signTypedData({
+   *   network: "base-sepolia",
+   *   typedData: {
+   *     domain: {
+   *       name: "Test",
+   *       chainId: 84532,
+   *       verifyingContract: "0x0000000000000000000000000000000000000000",
+   *     },
+   *     types: {
+   *       Test: [{ name: "name", type: "string" }],
+   *     },
+   *     primaryType: "Test",
+   *     message: {
+   *       name: "John Doe",
+   *     },
+   *   },
+   * });
+   * ```
+   */
+  signTypedData: (
+    options: Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks },
+  ) => Promise<Hex>;
 };

package/actions/solana/sendTransaction.ts

@@ -0,0 +1,38 @@
+import { SendTransactionOptions, TransactionResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Sends a Solana transaction using the Coinbase API.
+ *
+ * @param {CdpOpenApiClientType} apiClient - The API client to use.
+ * @param {SendTransactionOptions} options - Parameters for sending the Solana transaction.
+ * @param {string} options.network - The network to send the transaction to.
+ * @param {string} options.transaction - The base64 encoded transaction to send.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the transaction result.
+ *
+ * @example
+ * ```ts
+ * const signature = await sendTransaction({
+ *   network: "solana-devnet",
+ *   transaction: "...",
+ * });
+ * ```
+ */
+export async function sendTransaction(
+  apiClient: CdpOpenApiClientType,
+  options: SendTransactionOptions,
+): Promise<TransactionResult> {
+  const signature = await apiClient.sendSolanaTransaction(
+    {
+      network: options.network,
+      transaction: options.transaction,
+    },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.transactionSignature,
+  };
+}