@coinbase/cdp-sdk 1.18.0 → 1.20.0

package/actions/evm/transfer/transfer.ts

@@ -1,3 +1,5 @@
+import { isValidNetworkForAccount } from "./types.js";
+
 import type {
   TransferExecutionStrategy,
   SmartAccountTransferOptions,
@@ -24,6 +26,12 @@ export async function transfer<T extends EvmAccount | EvmSmartAccount>(
   transferArgs: T extends EvmSmartAccount ? SmartAccountTransferOptions : TransferOptions,
   transferStrategy: TransferExecutionStrategy<T>,
 ): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult> {
+  if (!isValidNetworkForAccount(transferArgs.network, from)) {
+    throw new Error(
+      `Network "${transferArgs.network}" is not supported for the given account type.`,
+    );
+  }
+
   const to =
     typeof transferArgs.to === "string" ? transferArgs.to : (transferArgs.to.address as Address);
 

package/actions/evm/transfer/transferWithViem.ts

@@ -0,0 +1,65 @@
+import { encodeFunctionData, erc20Abi } from "viem";
+
+import { getErc20Address } from "./utils.js";
+
+import type { Network, TransferOptions } from "./types.js";
+import type { EvmAccount } from "../../../accounts/evm/types.js";
+import type { Hex } from "../../../types/misc.js";
+import type { TransactionResult } from "../sendTransaction.js";
+import type { Account, Chain, Transport, WalletClient } from "viem";
+
+/**
+ * Transfer an amount of a token from a network-scoped account to another account.
+ * This function is used for accounts that are scoped to a specific network and use
+ * a wallet client for transaction execution instead of the API client.
+ *
+ * @param walletClient - The wallet client to use for transaction execution.
+ * @param from - The account to send the transaction from.
+ * @param transferArgs - The transfer options.
+ * @returns The result of the transfer.
+ */
+export async function transferWithViem<T extends EvmAccount>(
+  walletClient: WalletClient<Transport, Chain, Account>,
+  from: T,
+  transferArgs: TransferOptions,
+): Promise<TransactionResult> {
+  const token = transferArgs.token;
+  const to = typeof transferArgs.to === "string" ? transferArgs.to : transferArgs.to.address;
+  const value = transferArgs.amount;
+  const network = transferArgs.network;
+
+  if (token === "eth") {
+    const hash = await walletClient.sendTransaction({
+      account: from.address,
+      to,
+      value,
+    });
+    return { transactionHash: hash as Hex };
+  }
+
+  const erc20Address = getErc20Address(token, network as Network);
+
+  // First approve the transfer
+  await walletClient.sendTransaction({
+    account: from.address,
+    to: erc20Address,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "approve",
+      args: [to, value],
+    }),
+  });
+
+  // Then execute the transfer
+  const hash = await walletClient.sendTransaction({
+    account: from.address,
+    to: erc20Address,
+    data: encodeFunctionData({
+      abi: erc20Abi,
+      functionName: "transfer",
+      args: [to, value],
+    }),
+  });
+
+  return { transactionHash: hash as Hex };
+}

package/actions/evm/transfer/types.ts

@@ -1,8 +1,10 @@
+import { EvmUserOperationNetwork } from "../../../openapi-client/index.js";
+
 import type { EvmAccount, EvmSmartAccount } from "../../../accounts/evm/types.js";
 import type {
   CdpOpenApiClientType,
-  EvmUserOperationNetwork,
   SendEvmTransactionBodyNetwork,
+  EvmUserOperationNetwork as EvmUserOperationNetworkType,
 } from "../../../openapi-client/index.js";
 import type { TransactionResult } from "../sendTransaction.js";
 import type { SendUserOperationReturnType } from "../sendUserOperation.js";
@@ -64,3 +66,31 @@ export interface TransferExecutionStrategy<T extends EvmAccount | EvmSmartAccoun
     } & (T extends EvmSmartAccount ? { paymasterUrl?: string } : object),
   ): Promise<T extends EvmSmartAccount ? SendUserOperationReturnType : TransactionResult>;
 }
+
+/**
+ * Validates that the network is supported for the given account type.
+ *
+ * @param network - The network to validate
+ * @param account - The account to check network support for
+ * @returns true if the network is valid for the account type
+ */
+export function isValidNetworkForAccount(
+  network: Network,
+  account: EvmAccount | EvmSmartAccount,
+): boolean {
+  if (isSmartAccount(account)) {
+    return Object.values(EvmUserOperationNetwork).includes(network as EvmUserOperationNetworkType);
+  }
+
+  return true;
+}
+
+/**
+ * Type guard to check if an account is a smart account.
+ *
+ * @param account - The account to check.
+ * @returns true if the account is a smart account, false otherwise.
+ */
+export function isSmartAccount(account: EvmAccount | EvmSmartAccount): account is EvmSmartAccount {
+  return "type" in account && account.type === "evm-smart";
+}

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;
 
 /**
@@ -1488,6 +1490,8 @@ export type SendEvmTransactionBodyNetwork =
 export const SendEvmTransactionBodyNetwork = {
   base: "base",
   "base-sepolia": "base-sepolia",
+  ethereum: "ethereum",
+  "ethereum-sepolia": "ethereum-sepolia",
 } as const;
 
 export type SendEvmTransactionBody = {

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

@@ -1,8 +1,8 @@
 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-accounts/evm-accounts.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 "./solana-accounts/solana-accounts.msw.js";
+export * from "./policy-engine/policy-engine.msw.js";
+export * from "./payments-alpha/payments-alpha.msw.js";
+export * from "./evm-smart-accounts/evm-smart-accounts.msw.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coinbase/cdp-sdk",
-  "version": "1.18.0",
+  "version": "1.20.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.18.0";
+export const version = "1.20.0";