@coinbase/cdp-sdk 1.6.0 → 1.8.0

package/actions/evm/types.ts

@@ -1,14 +1,21 @@
-import { SendUserOperationReturnType, SendUserOperationOptions } from "./sendUserOperation.js";
+import { SendUserOperationOptions, SendUserOperationReturnType } from "./sendUserOperation.js";
+import { GetUserOperationOptions, UserOperation } from "../../client/evm/evm.types.js";
+import { EvmAccount, EvmSmartAccount } from "../../openapi-client/index.js";
 
-import type { ListTokenBalancesResult, ListTokenBalancesOptions } from "./listTokenBalances.js";
+import type { ListTokenBalancesOptions, ListTokenBalancesResult } from "./listTokenBalances.js";
 import type { RequestFaucetOptions, RequestFaucetResult } from "./requestFaucet.js";
 import type { SendTransactionOptions, TransactionResult } from "./sendTransaction.js";
-import type { TransferOptions, TransferResult } from "./transfer/types.js";
+import type {
+  AccountTransferOptions,
+  SmartAccountTransferOptions,
+  TransferResult,
+} from "./transfer/types.js";
 import type {
   WaitForUserOperationOptions,
   WaitForUserOperationReturnType,
 } from "./waitForUserOperation.js";
-export type Actions = {
+
+type Actions<T extends EvmAccount | EvmSmartAccount> = {
   /**
    * Transfer an amount of a token from an account to another account.
    *
@@ -92,7 +99,9 @@ export type Actions = {
    * });
    * ```
    */
-  transfer: (options: TransferOptions) => Promise<TransferResult>;
+  transfer: (
+    options: T extends EvmSmartAccount ? SmartAccountTransferOptions : AccountTransferOptions,
+  ) => Promise<TransferResult>;
 
   /**
    * List the token balances of an account.
@@ -132,7 +141,9 @@ export type Actions = {
    * ```
    */
   requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<RequestFaucetResult>;
+};
 
+export type AccountActions = Actions<EvmAccount> & {
   /**
    * Signs an EVM transaction and sends it to the specified network using the Coinbase API.
    * This method handles nonce management and gas estimation automatically.
@@ -178,7 +189,9 @@ export type Actions = {
    * ```
    */
   sendTransaction: (options: Omit<SendTransactionOptions, "address">) => Promise<TransactionResult>;
+};
 
+export type SmartAccountActions = Actions<EvmSmartAccount> & {
   /**
    * Sends a user operation.
    *
@@ -241,4 +254,23 @@ export type Actions = {
   waitForUserOperation: (
     options: Omit<WaitForUserOperationOptions, "smartAccountAddress">,
   ) => Promise<WaitForUserOperationReturnType>;
+
+  /**
+   * Gets a user operation by its hash.
+   *
+   * @param {GetUserOperationOptions} options - Parameters for getting the user operation.
+   * @param {string} options.userOpHash - The user operation hash.
+   *
+   * @returns A promise that resolves to the user operation.
+   *
+   * @example
+   * ```ts
+   * const userOp = await smartAccount.getUserOperation({
+   *   userOpHash: "0x1234567890123456789012345678901234567890",
+   * });
+   * ```
+   */
+  getUserOperation: (
+    options: Omit<GetUserOperationOptions, "smartAccount">,
+  ) => Promise<UserOperation>;
 };

package/actions/solana/requestFaucet.ts

@@ -0,0 +1,35 @@
+import { RequestFaucetOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Requests funds from a Solana faucet.
+ *
+ * @param apiClient - The API client.
+ * @param {RequestFaucetOptions} options - Parameters for requesting funds from the Solana faucet.
+ * @param {string} options.address - The address to request funds for.
+ * @param {string} options.token - The token to request funds for.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the transaction signature.
+ *
+ * @example
+ *          ```ts
+ *          const signature = await requestFaucet(cdp.solana, {
+ *            address: "1234567890123456789012345678901234567890",
+ *            token: "sol",
+ *          });
+ *          ```
+ */
+export async function requestFaucet(
+  apiClient: CdpOpenApiClientType,
+  options: RequestFaucetOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.requestSolanaFaucet(
+    { address: options.address, token: options.token },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.transactionSignature,
+  };
+}

package/actions/solana/signMessage.ts

@@ -0,0 +1,36 @@
+import { SignMessageOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Sign a message.
+ *
+ * @param apiClient - The API client.
+ * @param {SignMessageOptions} options - Parameters for signing the message.
+ * @param {string} options.address - The address to sign the message for.
+ * @param {string} options.message - The message to sign.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the transaction signature.
+ *
+ * @example
+ *          ```ts
+ *          const signature = await signMessage(cdp.solana, {
+ *            address: "1234567890123456789012345678901234567890",
+ *            message: "Hello, world!",
+ *          });
+ *          ```
+ */
+export async function signMessage(
+  apiClient: CdpOpenApiClientType,
+  options: SignMessageOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.signSolanaMessage(
+    options.address,
+    { message: options.message },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.signature,
+  };
+}

package/actions/solana/signTransaction.ts

@@ -0,0 +1,53 @@
+import { SignTransactionOptions, SignatureResult } from "../../client/solana/solana.types.js";
+import { CdpOpenApiClientType } from "../../openapi-client/index.js";
+
+/**
+ * Signs a transaction.
+ *
+ * @param apiClient - The API client.
+ * @param {SignTransactionOptions} options - Parameters for signing the transaction.
+ * @param {string} options.address - The address to sign the transaction for.
+ * @param {string} options.transaction - The transaction to sign.
+ * @param {string} [options.idempotencyKey] - An idempotency key.
+ *
+ * @returns A promise that resolves to the signature.
+ *
+ * @example
+ * ```ts
+ * // Create a Solana account
+ * const account = await cdp.solana.createAccount();
+ *
+ * // Add your transaction instructions here
+ * const transaction = new Transaction()
+ *
+ * // Make sure to set requireAllSignatures to false, since signing will be done through the API
+ * const serializedTransaction = transaction.serialize({
+ *   requireAllSignatures: false,
+ * });
+ *
+ * // Base64 encode the serialized transaction
+ * const transaction = Buffer.from(serializedTransaction).toString("base64");
+ *
+ * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+ * const signature = await signTransaction(cdp.solana, {
+ *   address: account.address,
+ *   transaction,
+ * });
+ * ```
+ */
+export async function signTransaction(
+  apiClient: CdpOpenApiClientType,
+  options: SignTransactionOptions,
+): Promise<SignatureResult> {
+  const signature = await apiClient.signSolanaTransaction(
+    options.address,
+    {
+      transaction: options.transaction,
+    },
+    options.idempotencyKey,
+  );
+
+  return {
+    signature: signature.signedTransaction,
+  };
+}

package/actions/solana/types.ts

@@ -0,0 +1,87 @@
+import {
+  RequestFaucetOptions,
+  SignatureResult,
+  SignMessageOptions,
+  SignTransactionOptions,
+} from "../../client/solana/solana.types.js";
+
+export type AccountActions = {
+  /**
+   * Requests funds from a Solana faucet.
+   *
+   * @param {RequestFaucetOptions} options - Parameters for requesting funds from the Solana faucet.
+   * @param {string} options.token - The token to request funds for.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the transaction hash.
+   *
+   * @example
+   * ```ts
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Request funds from the Solana faucet
+   * const result = await account.requestFaucet({
+   *   token: "sol",
+   * });
+   * ```
+   */
+  requestFaucet: (options: Omit<RequestFaucetOptions, "address">) => Promise<SignatureResult>;
+
+  /**
+   * Signs a message.
+   *
+   * @param {SignMessageOptions} options - Parameters for signing the message.
+   * @param {string} options.address - The address to sign the message for.
+   * @param {string} options.message - The message to sign.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Sign a message
+   * const { signature } = await account.signMessage({
+   *   message: "Hello, world!",
+   * });
+   * ```
+   */
+  signMessage: (options: Omit<SignMessageOptions, "address">) => Promise<SignatureResult>;
+
+  /**
+   * Signs a transaction.
+   *
+   * @param {SignTransactionOptions} options - Parameters for signing the transaction.
+   * @param {string} options.address - The address to sign the transaction for.
+   * @param {string} options.transaction - The transaction to sign.
+   * @param {string} [options.idempotencyKey] - An idempotency key.
+   *
+   * @returns A promise that resolves to the signature.
+   *
+   * @example
+   * ```ts
+   * // Create a Solana account
+   * const account = await cdp.solana.createAccount();
+   *
+   * // Add your transaction instructions here
+   * const transaction = new Transaction()
+   *
+   * // Make sure to set requireAllSignatures to false, since signing will be done through the API
+   * const serializedTransaction = transaction.serialize({
+   *   requireAllSignatures: false,
+   * });
+   *
+   * // Base64 encode the serialized transaction
+   * const transaction = Buffer.from(serializedTransaction).toString("base64");
+   *
+   * // When you want to sign a transaction, you can do so by address and base64 encoded transaction
+   * const { signature } = await account.signTransaction({
+   *   transaction,
+   * });
+   * ```
+   */
+  signTransaction: (options: Omit<SignTransactionOptions, "address">) => Promise<SignatureResult>;
+};

package/analytics.ts

@@ -1,5 +1,7 @@
 import md5 from "md5";
 
+import { APIError } from "./openapi-client/errors.js";
+
 /**
  * The data in an error event
  */
@@ -22,24 +24,33 @@ type ErrorEventData = {
   name: "error";
 };
 
-type EventData = ErrorEventData & {
-  apiKeyId: string;
-};
+type EventData = ErrorEventData;
 
 // This is a public client id for the analytics service
 const publicClientId = "54f2ee2fb3d2b901a829940d70fbfc13";
 
+export const Analytics = {
+  identifier: "", // set in cdp.ts
+  wrapClassWithErrorTracking,
+  wrapObjectMethodsWithErrorTracking,
+  sendEvent,
+};
+
 /**
  * Sends an analytics event to the default endpoint
  *
  * @param event - The event data containing event-specific fields
  * @returns Promise that resolves when the event is sent
  */
-export async function sendEvent(event: EventData): Promise<void> {
+async function sendEvent(event: EventData): Promise<void> {
+  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
+    return;
+  }
+
   const timestamp = Date.now();
 
   const enhancedEvent = {
-    user_id: event.apiKeyId,
+    user_id: Analytics.identifier,
     event_type: event.name,
     platform: "server",
     timestamp,
@@ -80,10 +91,13 @@ export async function sendEvent(event: EventData): Promise<void> {
  * Wraps all methods of a class with error tracking.
  *
  * @param ClassToWrap - The class whose prototype methods should be wrapped.
- * @param apiKeyId - The API key ID to use for the error tracking.
  */
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string): void {
+function wrapClassWithErrorTracking(ClassToWrap: any): void {
+  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
+    return;
+  }
+
   const methods = Object.getOwnPropertyNames(ClassToWrap.prototype).filter(
     name => name !== "constructor" && typeof ClassToWrap.prototype[name] === "function",
   );
@@ -94,14 +108,13 @@ export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string):
       try {
         return await originalMethod.apply(this, args);
       } catch (error) {
-        if (!(error instanceof Error)) {
-          return;
+        if (!shouldTrackError(error)) {
+          throw error;
         }
 
-        const { message, stack } = error;
+        const { message, stack } = error as Error;
 
         sendEvent({
-          apiKeyId,
           method,
           message,
           stack,
@@ -115,3 +128,63 @@ export function wrapClassWithErrorTracking(ClassToWrap: any, apiKeyId: string):
     };
   }
 }
+
+/**
+ * Wraps all methods of an object with error tracking.
+ *
+ * @param object - The object whose methods should be wrapped.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function wrapObjectMethodsWithErrorTracking(object: any): void {
+  if (process.env.DISABLE_CDP_ERROR_REPORTING === "true") {
+    return;
+  }
+
+  const methods = Object.getOwnPropertyNames(object).filter(
+    name => name !== "constructor" && typeof object[name] === "function",
+  );
+
+  for (const method of methods) {
+    const originalMethod = object[method];
+    object[method] = async function (...args: unknown[]) {
+      try {
+        return await originalMethod.apply(this, args);
+      } catch (error) {
+        if (!shouldTrackError(error)) {
+          throw error;
+        }
+
+        const { message, stack } = error as Error;
+
+        sendEvent({
+          method,
+          message,
+          stack,
+          name: "error",
+        }).catch(() => {
+          // ignore error
+        });
+
+        throw error;
+      }
+    };
+  }
+}
+
+/**
+ * Filters out non-errors and API errors
+ *
+ * @param error - The error to check.
+ * @returns True if the error should be tracked, false otherwise.
+ */
+function shouldTrackError(error: unknown): boolean {
+  if (!(error instanceof Error)) {
+    return false;
+  }
+
+  if (error instanceof APIError) {
+    return false;
+  }
+
+  return true;
+}

package/client/cdp.ts

@@ -1,7 +1,8 @@
-import { wrapClassWithErrorTracking } from "../analytics.js";
+import { Analytics } from "../analytics.js";
 import { CdpOpenApiClient } from "../openapi-client/index.js";
 import { version } from "../version.js";
 import { EvmClient } from "./evm/evm.js";
+import { PoliciesClient } from "./policies/policies.js";
 import { SolanaClient } from "./solana/solana.js";
 
 interface CdpClientOptions {
@@ -27,6 +28,9 @@ export class CdpClient {
   /** Namespace containing all Solana methods. */
   public solana: SolanaClient;
 
+  /** Namespace containing all Policies methods. */
+  public policies: PoliciesClient;
+
   /**
    * The CdpClient is the main class for interacting with the CDP API.
    *
@@ -109,12 +113,15 @@ For more information, see: https://github.com/coinbase/cdp-sdk/blob/main/typescr
     });
 
     if (process.env.DISABLE_CDP_ERROR_REPORTING !== "true") {
-      wrapClassWithErrorTracking(CdpClient, apiKeyId);
-      wrapClassWithErrorTracking(EvmClient, apiKeyId);
-      wrapClassWithErrorTracking(SolanaClient, apiKeyId);
+      Analytics.identifier = apiKeyId;
+      Analytics.wrapClassWithErrorTracking(CdpClient);
+      Analytics.wrapClassWithErrorTracking(EvmClient);
+      Analytics.wrapClassWithErrorTracking(SolanaClient);
+      Analytics.wrapClassWithErrorTracking(PoliciesClient);
     }
 
     this.evm = new EvmClient();
     this.solana = new SolanaClient();
+    this.policies = new PoliciesClient();
   }
 }