@coinbase/cdp-sdk 1.17.0 → 1.18.0

package/_types/version.d.ts

@@ -1,2 +1,2 @@
-export declare const version = "1.17.0";
+export declare const version = "1.18.0";
 //# sourceMappingURL=version.d.ts.map

package/accounts/evm/resolveViemClients.ts

@@ -0,0 +1,215 @@
+import {
+  Account,
+  createPublicClient,
+  createWalletClient,
+  http,
+  Transport,
+  type Chain,
+  type PublicClient,
+  type WalletClient,
+} from "viem";
+import { toAccount } from "viem/accounts";
+import * as chains from "viem/chains";
+
+import type { EvmAccount } from "./types.js";
+
+/**
+ * Network identifier to viem chain mapping
+ */
+const NETWORK_TO_CHAIN_MAP: Record<string, Chain> = {
+  base: chains.base,
+  "base-sepolia": chains.baseSepolia,
+  ethereum: chains.mainnet,
+  "ethereum-sepolia": chains.sepolia,
+  polygon: chains.polygon,
+  "polygon-mumbai": chains.polygonMumbai,
+  arbitrum: chains.arbitrum,
+  "arbitrum-sepolia": chains.arbitrumSepolia,
+  optimism: chains.optimism,
+  "optimism-sepolia": chains.optimismSepolia,
+};
+
+/**
+ * Get a chain from the viem chains object
+ *
+ * @param id - The chain ID
+ * @returns The chain
+ */
+function getChain(id: number): Chain {
+  const chainList = Object.values(chains) as Chain[];
+  const found = chainList.find(chain => chain.id === id);
+  if (!found) throw new Error(`Unsupported chain ID: ${id}`);
+  return found;
+}
+
+/**
+ * Determines if the input string is a network identifier or a Node URL
+ *
+ * @param input - The string to check
+ * @returns True if the input is a network identifier, false otherwise
+ */
+function isNetworkIdentifier(input: string): boolean {
+  const normalizedInput = input.toLowerCase();
+  return NETWORK_TO_CHAIN_MAP[normalizedInput] !== undefined;
+}
+
+/**
+ * Resolves a network identifier to a viem chain
+ *
+ * @param network - The network identifier to resolve
+ * @returns The resolved viem chain
+ */
+function resolveNetworkToChain(network: string): Chain {
+  const chain = NETWORK_TO_CHAIN_MAP[network.toLowerCase()];
+  if (!chain) {
+    throw new Error(`Unsupported network identifier: ${network}`);
+  }
+  return chain;
+}
+
+/**
+ * Resolves a Node URL to a viem chain by making a getChainId call
+ *
+ * @param nodeUrl - The Node URL to resolve
+ * @returns Promise resolving to the viem chain
+ */
+async function resolveNodeUrlToChain(nodeUrl: string): Promise<Chain> {
+  // First validate that it's a proper URL
+  if (!isValidUrl(nodeUrl)) {
+    throw new Error(`Invalid URL format: ${nodeUrl}`);
+  }
+
+  // Create a temporary public client to get the chain ID
+  const tempPublicClient = createPublicClient({
+    transport: http(nodeUrl),
+  });
+
+  try {
+    const chainId = await tempPublicClient.getChainId();
+    const chain = getChain(Number(chainId));
+    return chain;
+  } catch (error) {
+    throw new Error(
+      `Failed to resolve chain ID from Node URL: ${error instanceof Error ? error.message : "Unknown error"}`,
+    );
+  }
+}
+
+/**
+ * Determines if the input string is a valid URL
+ *
+ * @param input - The string to validate as a URL
+ * @returns True if the input is a valid URL, false otherwise
+ */
+function isValidUrl(input: string): boolean {
+  try {
+    new URL(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Options for resolving viem clients
+ */
+export type ResolveViemClientsOptions = {
+  /** The network identifier (e.g., "base", "base-sepolia") or Node URL */
+  networkOrNodeUrl: string;
+  /** Optional account to use for the wallet client */
+  account: EvmAccount;
+};
+
+/**
+ * Result of resolving viem clients
+ */
+export type ResolvedViemClients = {
+  /** The resolved viem chain */
+  chain: Chain;
+  /** The public client for reading blockchain data */
+  publicClient: PublicClient<Transport, Chain>;
+  /** The wallet client for sending transactions */
+  walletClient: WalletClient<Transport, Chain, Account>;
+};
+
+/**
+ * Resolves viem clients based on a network identifier or Node URL.
+ *
+ * @param options - Configuration options
+ * @param options.networkOrNodeUrl - Either a network identifier (e.g., "base", "base-sepolia") or a full Node URL
+ * @param options.account - Optional account to use for the wallet client
+ * @returns Promise resolving to an object containing the chain, publicClient, and walletClient
+ *
+ * @example
+ * ```typescript
+ * // Using network identifier
+ * const clients = await resolveViemClients({
+ *   networkOrNodeUrl: "base",
+ *   account: myAccount
+ * });
+ *
+ * // Using Node URL
+ * const clients = await resolveViemClients({
+ *   networkOrNodeUrl: "https://mainnet.base.org",
+ *   account: myAccount
+ * });
+ * ```
+ */
+export async function resolveViemClients(
+  options: ResolveViemClientsOptions,
+): Promise<ResolvedViemClients> {
+  const { networkOrNodeUrl } = options;
+
+  let chain: Chain;
+
+  // If it's a valid network identifier, use the mapping
+  if (isNetworkIdentifier(networkOrNodeUrl)) {
+    chain = resolveNetworkToChain(networkOrNodeUrl);
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(),
+    });
+    const walletClient = createWalletClient({
+      account: toAccount(options.account),
+      chain,
+      transport: http(),
+    });
+    return {
+      chain,
+      publicClient,
+      walletClient,
+    };
+  }
+
+  // If it's not a valid network identifier, try to treat it as a Node URL
+  try {
+    chain = await resolveNodeUrlToChain(networkOrNodeUrl);
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(networkOrNodeUrl),
+    });
+    const walletClient = createWalletClient({
+      account: toAccount(options.account),
+      chain,
+      transport: http(networkOrNodeUrl),
+    });
+    return {
+      chain,
+      publicClient,
+      walletClient,
+    };
+  } catch (error) {
+    // If the error is from resolveNodeUrlToChain, re-throw it as-is
+    if (
+      error instanceof Error &&
+      (error.message.includes("Invalid URL format") ||
+        error.message.includes("Unsupported chain ID") ||
+        error.message.includes("Failed to resolve chain ID"))
+    ) {
+      throw error;
+    }
+
+    // Otherwise, throw a generic error about unsupported input
+    throw new Error(`Unsupported network identifier or invalid Node URL: ${networkOrNodeUrl}`);
+  }
+}

package/accounts/evm/toEvmServerAccount.ts

@@ -169,7 +169,7 @@ export function toEvmServerAccount(
     name: options.account.name,
     type: "evm-server",
     policies: options.account.policies,
-    __experimental_useNetwork: async (networkOrRpcUrl: string) => {
+    useNetwork: async (networkOrRpcUrl: string) => {
       return toNetworkScopedEvmServerAccount(apiClient, {
         account,
         network: networkOrRpcUrl,

package/accounts/evm/toNetworkScopedEvmServerAccount.ts

@@ -1,6 +1,12 @@
+import { WaitForTransactionReceiptParameters } from "viem";
+import { base, baseSepolia, sepolia } from "viem/chains";
+
+import { resolveViemClients } from "./resolveViemClients.js";
+import { RequestFaucetOptions } from "../../actions/evm/requestFaucet.js";
+
 import type { EvmServerAccount, NetworkScopedEvmServerAccount } from "./types.js";
 import type { CdpOpenApiClientType } from "../../openapi-client/index.js";
-import type { Address } from "../../types/misc.js";
+import type { Address, TransactionRequestEIP1559 } from "../../types/misc.js";
 
 /**
  * Options for converting a pre-existing EvmAccount to a NetworkScopedEvmServerAccount.
@@ -22,10 +28,17 @@ export type ToNetworkScopedEvmServerAccountOptions = {
  * @param {string} options.network - The network to scope the account to.
  * @returns {NetworkScopedEvmServerAccount} A configured NetworkScopedEvmServerAccount instance ready for signing.
  */
-export function toNetworkScopedEvmServerAccount(
+export async function toNetworkScopedEvmServerAccount(
   apiClient: CdpOpenApiClientType,
   options: ToNetworkScopedEvmServerAccountOptions,
-): NetworkScopedEvmServerAccount {
+): Promise<NetworkScopedEvmServerAccount> {
+  const { publicClient, walletClient, chain } = await resolveViemClients({
+    networkOrNodeUrl: options.network,
+    account: options.account,
+  });
+
+  const shouldUseApi = chain.id === base.id || chain.id === baseSepolia.id;
+
   const account: NetworkScopedEvmServerAccount = {
     address: options.account.address as Address,
     network: options.network,
@@ -36,6 +49,33 @@ export function toNetworkScopedEvmServerAccount(
     name: options.account.name,
     type: "evm-server",
     policies: options.account.policies,
+    requestFaucet: async (faucetOptions: Omit<RequestFaucetOptions, "address" | "network">) => {
+      if (chain.id !== baseSepolia.id && chain.id !== sepolia.id) {
+        throw new Error(
+          "Requesting a faucet is supported only on base-sepolia or ethereum-sepolia",
+        );
+      }
+      return options.account.requestFaucet({
+        ...faucetOptions,
+        network: chain.id === baseSepolia.id ? "base-sepolia" : "ethereum-sepolia",
+      });
+    },
+    sendTransaction: async txOpts => {
+      if (shouldUseApi) {
+        return options.account.sendTransaction({
+          ...txOpts,
+          network: chain.id === base.id ? "base" : "base-sepolia",
+        });
+      } else {
+        const hash = await walletClient.sendTransaction(
+          txOpts.transaction as TransactionRequestEIP1559,
+        );
+        return { transactionHash: hash };
+      }
+    },
+    waitForTransactionReceipt: async (options: WaitForTransactionReceiptParameters) => {
+      return publicClient.waitForTransactionReceipt(options);
+    },
   };
 
   return account;

package/accounts/evm/types.ts

@@ -1,11 +1,16 @@
+import { RequestFaucetOptions, RequestFaucetResult } from "../../actions/evm/requestFaucet.js";
+import { TransactionResult, SendTransactionOptions } from "../../actions/evm/sendTransaction.js";
+
 import type { AccountActions, SmartAccountActions } from "../../actions/evm/types.js";
 import type { Address, Hash, Hex } from "../../types/misc.js";
 import type { Prettify } from "../../types/utils.js";
 import type {
   SignableMessage,
+  TransactionReceipt,
   TransactionSerializable,
   TypedData,
   TypedDataDefinition,
+  WaitForTransactionReceiptParameters,
 } from "viem";
 
 /**
@@ -42,8 +47,8 @@ export type EvmServerAccount = Prettify<
       name?: string;
       /** Indicates this is a server-managed account. */
       type: "evm-server";
-      /** Subject to breaking changes. A function that returns a network-scoped server-managed account. */
-      __experimental_useNetwork: (network: string) => Promise<NetworkScopedEvmServerAccount>;
+      /** A function that returns a network-scoped server-managed account. */
+      useNetwork: (network: string) => Promise<NetworkScopedEvmServerAccount>;
     }
 >;
 
@@ -72,12 +77,25 @@ export type NetworkScopedEvmSmartAccount = Prettify<
   }
 >;
 
+type NetworkScopedAccountActions = Prettify<{
+  requestFaucet: (
+    options: Omit<RequestFaucetOptions, "address" | "network">,
+  ) => Promise<RequestFaucetResult>;
+  sendTransaction: (
+    options: Omit<SendTransactionOptions, "address" | "network">,
+  ) => Promise<TransactionResult>;
+  waitForTransactionReceipt: (
+    options: WaitForTransactionReceiptParameters,
+  ) => Promise<TransactionReceipt>;
+}>;
+
 /**
  * A network-scoped server-managed ethereum account
  */
 export type NetworkScopedEvmServerAccount = Prettify<
-  Omit<EvmServerAccount, keyof AccountActions | "__experimental_useNetwork"> & {
-    /** The network this account is scoped to */
-    network: string;
-  }
+  Omit<EvmServerAccount, keyof AccountActions | "useNetwork"> &
+    NetworkScopedAccountActions & {
+      /** The network this account is scoped to */
+      network: string;
+    }
 >;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.17.0",
+  "version": "1.18.0",
   "description": "SDK for interacting with the Coinbase Developer Platform Wallet API",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",

package/version.ts

@@ -1 +1 @@
-export const version = "1.17.0";
+export const version = "1.18.0";