@coinbase/cdp-sdk 1.44.1 → 1.46.0

package/accounts/evm/toEvmSmartAccount.ts

@@ -1,3 +1,6 @@
+import { createPublicClient, http } from "viem";
+
+import { wrapSignatureWithEip6492IfUndeployed } from "./eip6492.js";
 import { resolveNetworkToChain } from "./networkToChainResolver.js";
 import { toNetworkScopedEvmSmartAccount } from "./toNetworkScopedEvmSmartAccount.js";
 import { getUserOperation } from "../../actions/evm/getUserOperation.js";
@@ -39,7 +42,7 @@ import {
   type EvmSmartAccount as EvmSmartAccountModel,
 } from "../../openapi-client/index.js";
 
-import type { EvmAccount, EvmSmartAccount, KnownEvmNetworks } from "./types.js";
+import type { EvmAccount, EvmSmartAccount, KnownEvmNetworks, NetworkOrRpcUrl } from "./types.js";
 import type {
   SmartAccountQuoteSwapOptions,
   SmartAccountQuoteSwapResult,
@@ -86,8 +89,12 @@ export function toEvmSmartAccount(
           network: transferArgs.network,
         },
       });
-
-      return transfer(apiClient, account, transferArgs, smartAccountTransferStrategy);
+      try {
+        return transfer(apiClient, account, transferArgs, smartAccountTransferStrategy);
+      } catch (error) {
+        Analytics.trackError(error, "transfer");
+        throw error;
+      }
     },
     async listTokenBalances(
       options: Omit<ListTokenBalancesOptions, "address">,
@@ -99,11 +106,15 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
-
-      return listTokenBalances(apiClient, {
-        ...options,
-        address: this.address,
-      });
+      try {
+        return listTokenBalances(apiClient, {
+          ...options,
+          address: this.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "listTokenBalances");
+        throw error;
+      }
     },
     async sendUserOperation(
       options: Omit<SendUserOperationOptions<unknown[]>, "smartAccount">,
@@ -115,11 +126,15 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
-
-      return sendUserOperation(apiClient, {
-        ...options,
-        smartAccount: account,
-      });
+      try {
+        return sendUserOperation(apiClient, {
+          ...options,
+          smartAccount: account,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "sendUserOperation");
+        throw error;
+      }
     },
     async waitForUserOperation(
       options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
@@ -128,11 +143,15 @@ export function toEvmSmartAccount(
         action: "wait_for_user_operation",
         accountType: "evm_smart",
       });
-
-      return waitForUserOperation(apiClient, {
-        ...options,
-        smartAccountAddress: account.address,
-      });
+      try {
+        return waitForUserOperation(apiClient, {
+          ...options,
+          smartAccountAddress: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "waitForUserOperation");
+        throw error;
+      }
     },
     async getUserOperation(
       options: Omit<GetUserOperationOptions, "smartAccount">,
@@ -141,11 +160,15 @@ export function toEvmSmartAccount(
         action: "get_user_operation",
         accountType: "evm_smart",
       });
-
-      return getUserOperation(apiClient, {
-        ...options,
-        smartAccount: account,
-      });
+      try {
+        return getUserOperation(apiClient, {
+          ...options,
+          smartAccount: account,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "getUserOperation");
+        throw error;
+      }
     },
     async requestFaucet(
       options: Omit<RequestFaucetOptions, "address">,
@@ -157,11 +180,15 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
-
-      return requestFaucet(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return requestFaucet(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "requestFaucet");
+        throw error;
+      }
     },
     async quoteSwap(options: SmartAccountQuoteSwapOptions): Promise<SmartAccountQuoteSwapResult> {
       Analytics.trackAction({
@@ -171,13 +198,17 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
-
-      return createSwapQuote(apiClient, {
-        ...options,
-        taker: this.address, // Always use smart account's address as taker
-        signerAddress: this.owners[0].address, // Always use owner's address as signer
-        smartAccount: account, // Pass smart account for execute method support
-      });
+      try {
+        return createSwapQuote(apiClient, {
+          ...options,
+          taker: this.address, // Always use smart account's address as taker
+          signerAddress: this.owners[0].address, // Always use owner's address as signer
+          smartAccount: account, // Pass smart account for execute method support
+        });
+      } catch (error) {
+        Analytics.trackError(error, "quoteSwap");
+        throw error;
+      }
     },
     async swap(options: SmartAccountSwapOptions): Promise<SmartAccountSwapResult> {
       Analytics.trackAction({
@@ -187,13 +218,17 @@ export function toEvmSmartAccount(
           network: "network" in options ? options.network : undefined,
         },
       });
-
-      return sendSwapOperation(apiClient, {
-        ...options,
-        smartAccount: account,
-        taker: this.address, // Always use smart account's address as taker
-        signerAddress: this.owners[0].address, // Always use owner's address as signer
-      });
+      try {
+        return sendSwapOperation(apiClient, {
+          ...options,
+          smartAccount: account,
+          taker: this.address, // Always use smart account's address as taker
+          signerAddress: this.owners[0].address, // Always use owner's address as signer
+        });
+      } catch (error) {
+        Analytics.trackError(error, "swap");
+        throw error;
+      }
     },
     async signTypedData(
       options: Omit<SignTypedDataOptions, "address"> & { network: KnownEvmNetworks },
@@ -205,13 +240,27 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
+      try {
+        const chain = resolveNetworkToChain(options.network);
 
-      const result = await signAndWrapTypedDataForSmartAccount(apiClient, {
-        chainId: BigInt(resolveNetworkToChain(options.network).id),
-        smartAccount: account,
-        typedData: options,
-      });
-      return result.signature;
+        const result = await signAndWrapTypedDataForSmartAccount(apiClient, {
+          chainId: BigInt(chain.id),
+          smartAccount: account,
+          typedData: options,
+        });
+
+        const publicClient = createPublicClient({ chain, transport: http() });
+
+        return wrapSignatureWithEip6492IfUndeployed(
+          publicClient,
+          account.address,
+          account.owners[0].address,
+          result.signature,
+        );
+      } catch (error) {
+        Analytics.trackError(error, "signTypedData");
+        throw error;
+      }
     },
     async useSpendPermission(
       options: UseSpendPermissionOptions,
@@ -223,13 +272,17 @@ export function toEvmSmartAccount(
           network: options.network,
         },
       });
-
-      return useSpendPermission(apiClient, account, options);
+      try {
+        return useSpendPermission(apiClient, account, options);
+      } catch (error) {
+        Analytics.trackError(error, "useSpendPermission");
+        throw error;
+      }
     },
 
     name: options.smartAccount.name,
     type: "evm-smart",
-    useNetwork: async <Network extends KnownEvmNetworks>(network: Network) => {
+    useNetwork: async <Network extends NetworkOrRpcUrl>(network: Network) => {
       Analytics.trackAction({
         action: "use_network",
         accountType: "evm_smart",
@@ -237,12 +290,16 @@ export function toEvmSmartAccount(
           network,
         },
       });
-
-      return toNetworkScopedEvmSmartAccount(apiClient, {
-        smartAccount: account,
-        owner: options.owner,
-        network,
-      });
+      try {
+        return toNetworkScopedEvmSmartAccount(apiClient, {
+          smartAccount: account,
+          owner: options.owner,
+          network,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "useNetwork");
+        throw error;
+      }
     },
   };
 

package/accounts/evm/toNetworkScopedEvmSmartAccount.ts

@@ -1,9 +1,12 @@
+import { wrapSignatureWithEip6492IfUndeployed } from "./eip6492.js";
 import { getBaseNodeRpcUrl } from "./getBaseNodeRpcUrl.js";
 import { isMethodSupportedOnNetwork } from "./networkCapabilities.js";
+import { resolveViemClients } from "./resolveViemClients.js";
 import { getUserOperation } from "../../actions/evm/getUserOperation.js";
 import { listTokenBalances } from "../../actions/evm/listTokenBalances.js";
 import { requestFaucet } from "../../actions/evm/requestFaucet.js";
 import { sendUserOperation } from "../../actions/evm/sendUserOperation.js";
+import { signAndWrapTypedDataForSmartAccount } from "../../actions/evm/signAndWrapTypedDataForSmartAccount.js";
 import { UseSpendPermissionOptions } from "../../actions/evm/spend-permissions/types.js";
 import { createSwapQuote } from "../../actions/evm/swap/createSwapQuote.js";
 import { sendSwapOperation } from "../../actions/evm/swap/sendSwapOperation.js";
@@ -15,7 +18,7 @@ import { Analytics } from "../../analytics.js";
 import type {
   EvmAccount,
   EvmSmartAccount,
-  KnownEvmNetworks,
+  NetworkOrRpcUrl,
   NetworkScopedEvmSmartAccount,
   DistributedOmit,
 } from "./types.js";
@@ -29,7 +32,7 @@ import type {
 } from "../../actions/evm/swap/types.js";
 import type { SmartAccountTransferOptions } from "../../actions/evm/transfer/types.js";
 import type { WaitForUserOperationOptions } from "../../actions/evm/waitForUserOperation.js";
-import type { GetUserOperationOptions } from "../../client/evm/evm.types.js";
+import type { GetUserOperationOptions, SignTypedDataOptions } from "../../client/evm/evm.types.js";
 import type {
   CdpOpenApiClientType,
   EvmUserOperationNetwork,
@@ -43,8 +46,8 @@ import type {
 export type ToNetworkScopedEvmSmartAccountOptions = {
   /** The pre-existing EvmSmartAccount. */
   smartAccount: EvmSmartAccount;
-  /** The network to scope the smart account object to. */
-  network: KnownEvmNetworks;
+  /** The network name or RPC URL to scope the smart account object to. */
+  network: NetworkOrRpcUrl;
   /** The owner of the smart account. */
   owner: EvmAccount;
 };
@@ -62,7 +65,7 @@ export type ToNetworkScopedEvmSmartAccountOptions = {
  * @param {KnownEvmNetworks} options.network - The network to scope the smart account to.
  * @returns {NetworkScopedEvmSmartAccount} A configured NetworkScopedEvmSmartAccount instance ready for user operation submission.
  */
-export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNetworks>(
+export async function toNetworkScopedEvmSmartAccount<Network extends NetworkOrRpcUrl>(
   apiClient: CdpOpenApiClientType,
   options: ToNetworkScopedEvmSmartAccountOptions & { network: Network },
 ): Promise<NetworkScopedEvmSmartAccount<Network>> {
@@ -278,5 +281,41 @@ export async function toNetworkScopedEvmSmartAccount<Network extends KnownEvmNet
     });
   }
 
+  Object.assign(account, {
+    signTypedData: async (typedDataOptions: Omit<SignTypedDataOptions, "address">) => {
+      Analytics.trackAction({
+        action: "sign_typed_data",
+        accountType: "evm_smart",
+        properties: {
+          network: options.network,
+          managed: true,
+        },
+      });
+
+      try {
+        const { publicClient, chain } = await resolveViemClients({
+          networkOrNodeUrl: options.network,
+          account: options.owner,
+        });
+
+        const result = await signAndWrapTypedDataForSmartAccount(apiClient, {
+          chainId: BigInt(chain.id),
+          smartAccount: options.smartAccount,
+          typedData: typedDataOptions,
+        });
+
+        return wrapSignatureWithEip6492IfUndeployed(
+          publicClient,
+          options.smartAccount.address,
+          options.smartAccount.owners[0].address,
+          result.signature,
+        );
+      } catch (error) {
+        Analytics.trackError(error, "signTypedData");
+        throw error;
+      }
+    },
+  });
+
   return account;
 }

package/accounts/evm/types.ts

@@ -34,7 +34,11 @@ import {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "../../actions/evm/waitForUserOperation.js";
-import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import {
+  GetUserOperationOptions,
+  SignTypedDataOptions,
+  UserOperation,
+} from "../../client/evm/evm.types.js";
 import { SpendPermissionNetwork } from "../../openapi-client/index.js";
 
 import type {
@@ -160,7 +164,7 @@ export type EvmSmartAccountProperties = {
    * // For custom RPC URLs without type hints (only sendTransaction, transfer and waitForTransactionReceipt methods available):
    * const customAccount = await smartAccount.useNetwork("https://mainnet.base.org");
    */
-  useNetwork: <Network extends KnownEvmNetworks>(
+  useNetwork: <Network extends NetworkOrRpcUrl>(
     network: Network,
   ) => Promise<NetworkScopedEvmSmartAccount<Network>>;
 };
@@ -176,7 +180,7 @@ export type EvmSmartAccount = Prettify<EvmSmartAccountProperties & SmartAccountA
  * @internal
  */
 export type NetworkSpecificSmartAccountActions<Network extends string> = Prettify<
-  // Always include sendUserOperation, waitForUserOperation and getUserOperation
+  // Always include sendUserOperation, waitForUserOperation, getUserOperation and signTypedData
   {
     sendUserOperation: <const callData extends unknown[]>(
       options: Omit<SendUserOperationOptions<callData>, "smartAccount" | "network">,
@@ -187,6 +191,7 @@ export type NetworkSpecificSmartAccountActions<Network extends string> = Prettif
     getUserOperation: (
       options: Omit<GetUserOperationOptions, "smartAccount" | "network">,
     ) => Promise<UserOperation>;
+    signTypedData: (options: Omit<SignTypedDataOptions, "address">) => Promise<Hex>;
   } & (Network extends TransferNetworks
     ? {
         transfer: (

package/accounts/solana/toSolanaAccount.ts

@@ -43,22 +43,30 @@ export function toSolanaAccount(
         action: "request_faucet",
         accountType: "solana",
       });
-
-      return requestFaucet(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return requestFaucet(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "requestFaucet");
+        throw error;
+      }
     },
     async signMessage(options: Omit<SignMessageOptions, "address">): Promise<SignatureResult> {
       Analytics.trackAction({
         action: "sign_message",
         accountType: "solana",
       });
-
-      return signMessage(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return signMessage(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "signMessage");
+        throw error;
+      }
     },
     async signTransaction(
       options: Omit<SignTransactionOptions, "address">,
@@ -67,11 +75,15 @@ export function toSolanaAccount(
         action: "sign_transaction",
         accountType: "solana",
       });
-
-      return signTransaction(apiClient, {
-        ...options,
-        address: account.address,
-      });
+      try {
+        return signTransaction(apiClient, {
+          ...options,
+          address: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "signTransaction");
+        throw error;
+      }
     },
     async sendTransaction(
       options: Omit<SendTransactionOptions, "address">,
@@ -80,10 +92,14 @@ export function toSolanaAccount(
         action: "send_transaction",
         accountType: "solana",
       });
-
-      return sendTransaction(apiClient, {
-        ...options,
-      });
+      try {
+        return sendTransaction(apiClient, {
+          ...options,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "sendTransaction");
+        throw error;
+      }
     },
     async transfer(options: Omit<TransferOptions, "from">): Promise<SignatureResult> {
       Analytics.trackAction({
@@ -93,11 +109,15 @@ export function toSolanaAccount(
           network: options.network,
         },
       });
-
-      return transfer(apiClient, {
-        ...options,
-        from: account.address,
-      });
+      try {
+        return transfer(apiClient, {
+          ...options,
+          from: account.address,
+        });
+      } catch (error) {
+        Analytics.trackError(error, "transfer");
+        throw error;
+      }
     },
   };
 

package/actions/evm/waitForEvmEip7702DelegationStatus.ts

@@ -0,0 +1,57 @@
+import {
+  CdpOpenApiClientType,
+  EvmEip7702DelegationOperation,
+  EvmEip7702DelegationOperationStatus,
+} from "../../openapi-client/index.js";
+import { wait, WaitOptions } from "../../utils/wait.js";
+
+/**
+ * Options for waiting for an EIP-7702 delegation operation to complete.
+ */
+export type WaitForEvmEip7702DelegationOperationStatusOptions = {
+  /** The delegation operation ID returned by createEvmEip7702Delegation. */
+  delegationOperationId: string;
+  /** Optional options for the wait operation. */
+  waitOptions?: WaitOptions;
+};
+
+/**
+ * Polls getEvmEip7702DelegationOperationById until the status is COMPLETED or FAILED, or a timeout occurs.
+ *
+ * @example
+ * ```ts
+ * import { waitForEvmEip7702DelegationOperationStatus } from "@coinbase/cdp-sdk";
+ *
+ * const operation = await waitForEvmEip7702DelegationOperationStatus(client, {
+ *   delegationOperationId: "delegation-op-123",
+ *   waitOptions: {
+ *     timeoutSeconds: 60,
+ *   },
+ * });
+ * ```
+ *
+ * @param {CdpOpenApiClientType} client - The client to use.
+ * @param {WaitForEvmEip7702DelegationOperationStatusOptions} options - The options for the wait operation.
+ * @returns {Promise<EvmEip7702DelegationOperation>} The delegation operation once it reaches a terminal status.
+ */
+export async function waitForEvmEip7702DelegationOperationStatus(
+  client: CdpOpenApiClientType,
+  options: WaitForEvmEip7702DelegationOperationStatusOptions,
+): Promise<EvmEip7702DelegationOperation> {
+  const { delegationOperationId } = options;
+
+  const reload = async () => {
+    return client.getEvmEip7702DelegationOperationById(delegationOperationId);
+  };
+
+  const isTerminal = (operation: EvmEip7702DelegationOperation): boolean => {
+    return (
+      operation.status === EvmEip7702DelegationOperationStatus.COMPLETED ||
+      operation.status === EvmEip7702DelegationOperationStatus.FAILED
+    );
+  };
+
+  const waitOptions = options.waitOptions ?? { timeoutSeconds: 60 };
+
+  return await wait(reload, isTerminal, s => s, waitOptions);
+}

package/actions/solana/transfer.ts

@@ -11,7 +11,6 @@ import {
   createNoopSigner,
   getBase64EncodedWireTransaction,
 } from "@solana/kit";
-import { Connection } from "@solana/web3.js";
 import { getTransferSolInstruction } from "@solana-program/system";
 import {
   findAssociatedTokenPda,
@@ -29,6 +28,7 @@ import {
   getOrCreateConnection,
   getUsdcMintAddress,
   type Network,
+  type SolanaRpcClient,
 } from "./utils.js";
 
 import type { SignatureResult } from "../../client/solana/solana.types.js";
@@ -52,9 +52,9 @@ export interface TransferOptions {
    */
   token: "sol" | "usdc" | string;
   /**
-   * The network to use which will be used to create an RPC client, otherwise an RPC client can be provided.
+   * The network to use which will be used to create an RPC client, otherwise an existing RPC client can be provided.
    */
-  network: Network | Connection;
+  network: Network | SolanaRpcClient;
 }
 
 /**