@coinbase/cdp-sdk 1.17.0 → 1.19.0

package/_types/utils/bigint.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Converts bigint values in an object to strings for safe serialization
+ *
+ * @param obj - The object to convert
+ * @returns A new object with bigint values converted to strings
+ */
+export declare const convertBigIntsToStrings: (obj: any) => any;
+//# sourceMappingURL=bigint.d.ts.map

package/_types/utils/bigint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bigint.d.ts","sourceRoot":"","sources":["../../utils/bigint.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,GAAI,KAAK,GAAG,KAAG,GAWlD,CAAC"}

package/_types/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare const hash: (data: Buffer) => string;
+//# sourceMappingURL=hash.d.ts.map

package/_types/utils/hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../utils/hash.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,IAAI,GAAI,MAAM,MAAM,WAAoD,CAAC"}

package/_types/utils/sortKeys.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Recursively sorts object keys to ensure consistent JSON stringification
+ *
+ * @param obj - The object to sort
+ * @returns A new object with sorted keys
+ */
+export declare const sortKeys: (obj: any) => any;
+//# sourceMappingURL=sortKeys.d.ts.map

package/_types/utils/sortKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sortKeys.d.ts","sourceRoot":"","sources":["../../utils/sortKeys.ts"],"names":[],"mappings":"AACA;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,KAAK,GAAG,KAAG,GAkBnC,CAAC"}

package/_types/version.d.ts

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

package/accounts/evm/resolveViemClients.ts

@@ -0,0 +1,259 @@
+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 { generateJwt } from "../../auth/utils/jwt.js";
+import { config } from "../../openapi-client/cdpApiClient.js";
+
+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>;
+};
+
+/**
+ * Get the base node RPC URL for a given network
+ *
+ * @param network - The network identifier
+ * @returns The base node RPC URL or undefined if the network is not supported
+ */
+async function getBaseNodeRpcUrl(network: "base" | "base-sepolia"): Promise<string | undefined> {
+  if (!config) {
+    return;
+  }
+
+  try {
+    const basePath = config.basePath?.replace("/platform", "");
+
+    const jwt = await generateJwt({
+      apiKeyId: config.apiKeyId,
+      apiKeySecret: config.apiKeySecret,
+      requestMethod: "GET",
+      requestHost: basePath.replace("https://", ""),
+      requestPath: "/apikeys/v1/tokens/active",
+    });
+
+    const response = await fetch(`${basePath}/apikeys/v1/tokens/active`, {
+      headers: {
+        Authorization: `Bearer ${jwt}`,
+        "Content-Type": "application/json",
+      },
+    });
+
+    const json = await response.json();
+    return `${basePath}/rpc/v1/${network}/${json.id}`;
+  } catch {
+    return;
+  }
+}
+
+/**
+ * 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)) {
+    const rpcUrl =
+      networkOrNodeUrl === "base" || networkOrNodeUrl === "base-sepolia"
+        ? await getBaseNodeRpcUrl(networkOrNodeUrl)
+        : undefined;
+
+    chain = resolveNetworkToChain(networkOrNodeUrl);
+    const publicClient = createPublicClient({
+      chain,
+      transport: http(rpcUrl),
+    });
+    const walletClient = createWalletClient({
+      account: toAccount(options.account),
+      chain,
+      transport: http(rpcUrl),
+    });
+    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,13 @@
+import { WaitForTransactionReceiptParameters } from "viem";
+import { base, baseSepolia, sepolia } from "viem/chains";
+
+import { resolveViemClients } from "./resolveViemClients.js";
+
 import type { EvmServerAccount, NetworkScopedEvmServerAccount } from "./types.js";
+import type { RequestFaucetOptions } from "../../actions/evm/requestFaucet.js";
+import type { TransactionResult } from "../../actions/evm/sendTransaction.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 +29,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 +50,40 @@ 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 | TransactionResult,
+    ) => {
+      if ("transactionHash" in options) {
+        return publicClient.waitForTransactionReceipt({
+          hash: options.transactionHash,
+        });
+      }
+      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 | TransactionResult,
+  ) => 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/auth/hooks/axios/withAuth.ts

@@ -1,5 +1,6 @@
 import { AxiosInstance, AxiosHeaders } from "axios";
 
+import { convertBigIntsToStrings } from "../../../utils/bigint.js";
 import { getAuthHeaders } from "../../utils/http.js";
 
 export interface AuthInterceptorOptions {
@@ -57,6 +58,11 @@ export function withAuth(axiosClient: AxiosInstance, options: AuthInterceptorOpt
     // Parse URL to get host and path
     const url = new URL(fullyQualifiedURL);
 
+    // Convert bigints in request body to strings for safe serialization
+    if (axiosConfig.data) {
+      axiosConfig.data = convertBigIntsToStrings(axiosConfig.data);
+    }
+
     // Get authentication headers
     const headers = await getAuthHeaders({
       apiKeyId: options.apiKeyId,

package/auth/utils/jwt.ts

@@ -3,6 +3,8 @@ import { createPrivateKey } from "crypto";
 
 import { SignJWT, importPKCS8, importJWK, JWTPayload } from "jose";
 
+import { hash } from "../../utils/hash.js";
+import { sortKeys } from "../../utils/sortKeys.js";
 import { InvalidWalletSecretFormatError, UndefinedWalletSecretError } from "../errors.js";
 
 /**
@@ -190,7 +192,8 @@ export async function generateWalletJwt(options: WalletJwtOptions): Promise<stri
   };
 
   if (Object.keys(options.requestData).length > 0) {
-    claims.req = options.requestData;
+    const sortedData = sortKeys(options.requestData);
+    claims.reqHash = hash(Buffer.from(JSON.stringify(sortedData)));
   }
 
   try {

package/index.ts

@@ -7,3 +7,5 @@ export {
   type CreatePolicyBody,
   type UpdatePolicyBody,
 } from "./policies/schema.js";
+
+export { parseEther } from "viem";

package/openapi-client/cdpApiClient.ts

@@ -11,6 +11,8 @@ import {
   UnknownError,
 } from "./errors.js";
 
+import type { Prettify } from "../types/utils.js";
+
 /**
  * The options for the CDP API.
  */
@@ -54,14 +56,24 @@ export type CdpOptions = {
 
 let axiosInstance: AxiosInstance;
 
+export let config: Prettify<Omit<CdpOptions, "basePath"> & { basePath: string }> | undefined =
+  undefined;
+
 /**
  * Configures the CDP client with the given options.
  *
  * @param {CdpOptions} options - The CDP options.
  */
 export const configure = (options: CdpOptions) => {
+  const baseURL = options.basePath || "https://api.cdp.coinbase.com/platform";
+
+  config = {
+    ...options,
+    basePath: baseURL,
+  };
+
   axiosInstance = Axios.create({
-    baseURL: options.basePath || "https://api.cdp.coinbase.com/platform",
+    baseURL,
   });
 
   axiosInstance = withAuth(axiosInstance, {

package/openapi-client/generated/coinbaseDeveloperPlatformAPIs.schemas.ts

@@ -56,6 +56,7 @@ export const ErrorType = {
   unauthorized: "unauthorized",
   policy_violation: "policy_violation",
   policy_in_use: "policy_in_use",
+  account_limit_exceeded: "account_limit_exceeded",
 } as const;
 
 /**
@@ -487,6 +488,7 @@ export type ListEvmTokenBalancesNetwork =
 export const ListEvmTokenBalancesNetwork = {
   base: "base",
   "base-sepolia": "base-sepolia",
+  ethereum: "ethereum",
 } as const;
 
 /**

package/openapi-client/generated/index.msw.ts

@@ -1,8 +1,8 @@
+export * from "./evm-swaps/evm-swaps.msw.js";
 export * from "./evm-token-balances/evm-token-balances.msw.js";
 export * from "./evm-accounts/evm-accounts.msw.js";
-export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
-export * from "./faucets/faucets.msw.js";
-export * from "./evm-swaps/evm-swaps.msw.js";
-export * from "./payments-alpha/payments-alpha.msw.js";
 export * from "./policy-engine/policy-engine.msw.js";
+export * from "./faucets/faucets.msw.js";
+export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";
 export * from "./solana-accounts/solana-accounts.msw.js";
+export * from "./payments-alpha/payments-alpha.msw.js";

package/package.json

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

package/utils/bigint.ts

@@ -0,0 +1,19 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Converts bigint values in an object to strings for safe serialization
+ *
+ * @param obj - The object to convert
+ * @returns A new object with bigint values converted to strings
+ */
+export const convertBigIntsToStrings = (obj: any): any => {
+  if (typeof obj === "bigint") {
+    return obj.toString();
+  }
+  if (Array.isArray(obj)) {
+    return obj.map(convertBigIntsToStrings);
+  }
+  if (obj && typeof obj === "object") {
+    return Object.fromEntries(Object.entries(obj).map(([k, v]) => [k, convertBigIntsToStrings(v)]));
+  }
+  return obj;
+};

package/utils/hash.ts

@@ -0,0 +1,3 @@
+import { createHash } from "crypto";
+
+export const hash = (data: Buffer) => createHash("sha256").update(data).digest("hex");

package/utils/sortKeys.ts

@@ -0,0 +1,26 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * Recursively sorts object keys to ensure consistent JSON stringification
+ *
+ * @param obj - The object to sort
+ * @returns A new object with sorted keys
+ */
+export const sortKeys = (obj: any): any => {
+  if (!obj || typeof obj !== "object") {
+    return obj;
+  }
+
+  if (Array.isArray(obj)) {
+    return obj.map(sortKeys);
+  }
+
+  return Object.keys(obj)
+    .sort()
+    .reduce(
+      (acc, key) => {
+        acc[key] = sortKeys(obj[key]);
+        return acc;
+      },
+      {} as Record<string, any>,
+    );
+};

package/version.ts

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