@coinbase/cdp-sdk 1.26.0 → 1.28.0

package/errors.ts

@@ -15,3 +15,21 @@ export class TimeoutError extends Error {
     }
   }
 }
+
+/**
+ * UserInputValidationError is thrown when validation of a user-supplied input fails.
+ */
+export class UserInputValidationError extends Error {
+  /**
+   * Initializes a new UserInputValidationError instance.
+   *
+   * @param message - The user input validation error message.
+   */
+  constructor(message: string) {
+    super(message);
+    this.name = "UserInputValidationError";
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, UserInputValidationError);
+    }
+  }
+}

package/index.ts

@@ -7,5 +7,6 @@ export {
   type CreatePolicyBody,
   type UpdatePolicyBody,
 } from "./policies/schema.js";
+export { NetworkError } from "./openapi-client/errors.js";
 
 export { parseEther } from "viem";

package/openapi-client/cdpApiClient.ts

@@ -3,13 +3,7 @@ import Axios, { AxiosInstance, AxiosRequestConfig } from "axios";
 
 import { withAuth } from "../auth/hooks/axios/index.js";
 import { ERROR_DOCS_PAGE_URL } from "../constants.js";
-import {
-  isOpenAPIError,
-  APIError,
-  HttpErrorType,
-  UnknownApiError,
-  UnknownError,
-} from "./errors.js";
+import { isOpenAPIError, APIError, UnknownError, NetworkError } from "./errors.js";
 
 import type { Prettify } from "../types/utils.js";
 
@@ -135,11 +129,52 @@ export const cdpApiClient = async <T>(
   } catch (error) {
     // eslint-disable-next-line import/no-named-as-default-member
     if (Axios.isAxiosError(error) && !error.response) {
-      throw new UnknownApiError(
-        HttpErrorType.unknown,
-        error.cause instanceof Error ? error.cause.message : error.message,
-        error.cause,
-      );
+      // Network-level errors (no response received)
+      const errorMessage = (error.message || "").toLowerCase();
+      const errorCode = error.code?.toLowerCase();
+
+      // Categorize network errors based on error messages and codes
+      if (errorCode === "econnrefused" || errorMessage.includes("connection refused")) {
+        throw new NetworkError(
+          "network_connection_failed",
+          "Unable to connect to CDP service. The service may be unavailable.",
+          { code: error.code, message: error.message, retryable: true },
+          error.cause,
+        );
+      } else if (
+        errorCode === "etimedout" ||
+        errorCode === "econnaborted" ||
+        errorMessage.includes("timeout")
+      ) {
+        throw new NetworkError(
+          "network_timeout",
+          "Request timed out. Please try again.",
+          { code: error.code, message: error.message, retryable: true },
+          error.cause,
+        );
+      } else if (errorCode === "enotfound" || errorMessage.includes("getaddrinfo")) {
+        throw new NetworkError(
+          "network_dns_failure",
+          "DNS resolution failed. Please check your network connection.",
+          { code: error.code, message: error.message, retryable: false },
+          error.cause,
+        );
+      } else if (errorMessage.includes("network error") || errorMessage.includes("econnreset")) {
+        throw new NetworkError(
+          "network_connection_failed",
+          "Network error occurred. Please check your connection and try again.",
+          { code: error.code, message: error.message, retryable: true },
+          error.cause,
+        );
+      } else {
+        // Generic network error
+        throw new NetworkError(
+          "unknown",
+          error.cause instanceof Error ? error.cause.message : error.message,
+          { code: error.code, message: error.message, retryable: true },
+          error.cause,
+        );
+      }
     }
 
     // eslint-disable-next-line import/no-named-as-default-member
@@ -155,20 +190,55 @@ export const cdpApiClient = async <T>(
         );
       } else {
         const statusCode = error.response.status;
+        const responseData = error.response.data;
+
+        // Check for gateway-level errors that might indicate network issues
+        const isGatewayError =
+          responseData &&
+          typeof responseData === "string" &&
+          (responseData.toLowerCase().includes("forbidden") ||
+            responseData.toLowerCase().includes("ip") ||
+            responseData.toLowerCase().includes("blocked") ||
+            responseData.toLowerCase().includes("gateway"));
+
         switch (statusCode) {
           case 401:
             throw new APIError(
               statusCode,
-              HttpErrorType.unauthorized,
+              "unauthorized",
               "Unauthorized.",
               undefined,
               `${ERROR_DOCS_PAGE_URL}#unauthorized`,
               error.cause,
             );
+          case 403:
+            // Special handling for IP blocklist and other gateway-level 403s
+            if (isGatewayError) {
+              throw new NetworkError(
+                "network_ip_blocked",
+                "Access denied. Your IP address may be blocked or restricted.",
+                {
+                  code: "IP_BLOCKED",
+                  message:
+                    typeof responseData === "string" ? responseData : JSON.stringify(responseData),
+                  retryable: false,
+                },
+                error.cause,
+              );
+            }
+            // Regular 403 forbidden error
+            throw new APIError(
+              statusCode,
+              "unauthorized",
+              "Forbidden. You don't have permission to access this resource.",
+              undefined,
+              `${ERROR_DOCS_PAGE_URL}#forbidden`,
+              error.cause,
+            );
           case 404:
             throw new APIError(
               statusCode,
-              HttpErrorType.not_found,
+              "not_found",
               "API not found.",
               undefined,
               `${ERROR_DOCS_PAGE_URL}#not_found`,
@@ -177,7 +247,7 @@ export const cdpApiClient = async <T>(
           case 502:
             throw new APIError(
               statusCode,
-              HttpErrorType.bad_gateway,
+              "bad_gateway",
               "Bad gateway.",
               undefined,
               `${ERROR_DOCS_PAGE_URL}`,
@@ -186,7 +256,7 @@ export const cdpApiClient = async <T>(
           case 503:
             throw new APIError(
               statusCode,
-              HttpErrorType.service_unavailable,
+              "service_unavailable",
               "Service unavailable. Please try again later.",
               undefined,
               `${ERROR_DOCS_PAGE_URL}`,
@@ -209,7 +279,7 @@ export const cdpApiClient = async <T>(
 
             throw new APIError(
               statusCode,
-              HttpErrorType.unexpected_error,
+              "unexpected_error",
               errorMessage,
               undefined,
               `${ERROR_DOCS_PAGE_URL}`,

package/openapi-client/errors.ts

@@ -1,18 +1,20 @@
+import { ERROR_DOCS_PAGE_URL } from "../constants.js";
 import {
   Error as OpenAPIError,
   ErrorType as OpenAPIErrorType,
 } from "./generated/coinbaseDeveloperPlatformAPIs.schemas.js";
 
-export const HttpErrorType = {
-  unexpected_error: "unexpected_error",
-  unauthorized: "unauthorized",
-  not_found: "not_found",
-  bad_gateway: "bad_gateway",
-  service_unavailable: "service_unavailable",
-  unknown: "unknown",
-} as const;
-
-export type HttpErrorType = (typeof HttpErrorType)[keyof typeof HttpErrorType];
+export type HttpErrorType =
+  | "unexpected_error"
+  | "unauthorized"
+  | "not_found"
+  | "bad_gateway"
+  | "service_unavailable"
+  | "unknown"
+  | "network_timeout"
+  | "network_connection_failed"
+  | "network_ip_blocked"
+  | "network_dns_failure";
 
 /**
  * Extended error codes that include both OpenAPI errors and network errors
@@ -114,6 +116,59 @@ export class UnknownError extends Error {
   }
 }
 
+/**
+ * Error thrown when a network-level failure occurs before reaching the CDP service
+ * This includes gateway errors, IP blocklist rejections, DNS failures, etc.
+ */
+export class NetworkError extends APIError {
+  networkDetails?: {
+    code?: string;
+    message?: string;
+    retryable?: boolean;
+  };
+
+  /**
+   * Constructor for the NetworkError class
+   *
+   * @param errorType - The type of network error
+   * @param errorMessage - The error message
+   * @param networkDetails - Additional network error details
+   * @param networkDetails.code - The error code
+   * @param networkDetails.message - The error message
+   * @param networkDetails.retryable - Whether the error is retryable
+   * @param cause - The cause of the error
+   */
+  constructor(
+    errorType: HttpErrorType,
+    errorMessage: string,
+    networkDetails?: { code?: string; message?: string; retryable?: boolean },
+    cause?: Error,
+  ) {
+    super(
+      0, // Status code 0 indicates no response was received
+      errorType,
+      errorMessage,
+      undefined,
+      `${ERROR_DOCS_PAGE_URL}#network-errors`,
+      cause,
+    );
+    this.name = "NetworkError";
+    this.networkDetails = networkDetails;
+  }
+
+  /**
+   * Convert the error to a JSON object, including network details
+   *
+   * @returns The error as a JSON object
+   */
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      ...(this.networkDetails && { networkDetails: this.networkDetails }),
+    };
+  }
+}
+
 /**
  * Type guard to check if an object is an OpenAPIError
  *

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

@@ -2252,6 +2252,30 @@ export type SignSolanaMessage200 = {
   signature: string;
 };
 
+/**
+ * The Solana network to send the transaction to.
+ */
+export type SendSolanaTransactionBodyNetwork =
+  (typeof SendSolanaTransactionBodyNetwork)[keyof typeof SendSolanaTransactionBodyNetwork];
+
+// eslint-disable-next-line @typescript-eslint/no-redeclare
+export const SendSolanaTransactionBodyNetwork = {
+  solana: "solana",
+  "solana-devnet": "solana-devnet",
+} as const;
+
+export type SendSolanaTransactionBody = {
+  /** The Solana network to send the transaction to. */
+  network: SendSolanaTransactionBodyNetwork;
+  /** The base64 encoded transaction to sign and send. This transaction can contain multiple instructions for native Solana batching. */
+  transaction: string;
+};
+
+export type SendSolanaTransaction200 = {
+  /** The base58 encoded transaction signature. */
+  transactionSignature: string;
+};
+
 /**
  * The token to request funds for.
  */

package/openapi-client/generated/solana-accounts/solana-accounts.msw.ts

@@ -13,6 +13,7 @@ import type {
   ExportSolanaAccount200,
   ExportSolanaAccountByName200,
   ListSolanaAccounts200,
+  SendSolanaTransaction200,
   SignSolanaMessage200,
   SignSolanaTransaction200,
   SolanaAccount,
@@ -203,6 +204,13 @@ export const getSignSolanaMessageResponseMock = (
   overrideResponse: Partial<SignSolanaMessage200> = {},
 ): SignSolanaMessage200 => ({ signature: faker.string.alpha(20), ...overrideResponse });
 
+export const getSendSolanaTransactionResponseMock = (
+  overrideResponse: Partial<SendSolanaTransaction200> = {},
+): SendSolanaTransaction200 => ({
+  transactionSignature: faker.string.alpha(20),
+  ...overrideResponse,
+});
+
 export const getListSolanaAccountsMockHandler = (
   overrideResponse?:
     | ListSolanaAccounts200
@@ -432,6 +440,29 @@ export const getSignSolanaMessageMockHandler = (
     );
   });
 };
+
+export const getSendSolanaTransactionMockHandler = (
+  overrideResponse?:
+    | SendSolanaTransaction200
+    | ((
+        info: Parameters<Parameters<typeof http.post>[1]>[0],
+      ) => Promise<SendSolanaTransaction200> | SendSolanaTransaction200),
+) => {
+  return http.post("*/v2/solana/accounts/send/transaction", async info => {
+    await delay(0);
+
+    return new HttpResponse(
+      JSON.stringify(
+        overrideResponse !== undefined
+          ? typeof overrideResponse === "function"
+            ? await overrideResponse(info)
+            : overrideResponse
+          : getSendSolanaTransactionResponseMock(),
+      ),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  });
+};
 export const getSolanaAccountsMock = () => [
   getListSolanaAccountsMockHandler(),
   getCreateSolanaAccountMockHandler(),
@@ -443,4 +474,5 @@ export const getSolanaAccountsMock = () => [
   getExportSolanaAccountByNameMockHandler(),
   getSignSolanaTransactionMockHandler(),
   getSignSolanaMessageMockHandler(),
+  getSendSolanaTransactionMockHandler(),
 ];

package/openapi-client/generated/solana-accounts/solana-accounts.ts

@@ -14,6 +14,8 @@ import type {
   ImportSolanaAccountBody,
   ListSolanaAccounts200,
   ListSolanaAccountsParams,
+  SendSolanaTransaction200,
+  SendSolanaTransactionBody,
   SignSolanaMessage200,
   SignSolanaMessageBody,
   SignSolanaTransaction200,
@@ -210,6 +212,44 @@ export const signSolanaMessage = (
     options,
   );
 };
+/**
+ * Signs and sends a single Solana transaction using multiple Solana accounts. The transaction may contain contain several instructions, each of which may require signatures from different account keys.
+
+The transaction should be serialized into a byte array and base64 encoded. The API handles recent blockhash management and fee estimation, leaving the developer to provide only the minimal set of fields necessary to send the transaction.
+
+**Transaction types**
+
+The following transaction types are supported:
+* [Legacy transactions](https://solana.com/developers/guides/advanced/versions#current-transaction-versions)
+* [Versioned transactions](https://solana.com/developers/guides/advanced/versions)
+
+**Instruction Batching**
+
+To batch multiple operations, include multiple instructions within a single transaction. All instructions within a transaction are executed atomically - if any instruction fails, the entire transaction fails and is rolled back.
+
+**Network Support**
+
+The following Solana networks are supported:
+* `solana` - Solana Mainnet
+* `solana-devnet` - Solana Devnet
+
+The developer is responsible for ensuring that the unsigned transaction is valid, as the API will not validate the transaction.
+ * @summary Send a Solana transaction
+ */
+export const sendSolanaTransaction = (
+  sendSolanaTransactionBody: SendSolanaTransactionBody,
+  options?: SecondParameter<typeof cdpApiClient>,
+) => {
+  return cdpApiClient<SendSolanaTransaction200>(
+    {
+      url: `/v2/solana/accounts/send/transaction`,
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      data: sendSolanaTransactionBody,
+    },
+    options,
+  );
+};
 export type ListSolanaAccountsResult = NonNullable<Awaited<ReturnType<typeof listSolanaAccounts>>>;
 export type CreateSolanaAccountResult = NonNullable<
   Awaited<ReturnType<typeof createSolanaAccount>>
@@ -234,3 +274,6 @@ export type SignSolanaTransactionResult = NonNullable<
   Awaited<ReturnType<typeof signSolanaTransaction>>
 >;
 export type SignSolanaMessageResult = NonNullable<Awaited<ReturnType<typeof signSolanaMessage>>>;
+export type SendSolanaTransactionResult = NonNullable<
+  Awaited<ReturnType<typeof sendSolanaTransaction>>
+>;

package/package.json

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

package/policies/schema.ts

@@ -66,9 +66,9 @@ export const EvmAddressCriterionSchema = z.object({
   /**
    * Array of EVM addresses to compare against.
    * Each address must be a 0x-prefixed 40-character hexadecimal string.
-   * Limited to a maximum of 100 addresses per criterion.
+   * Limited to a maximum of 300 addresses per criterion.
    */
-  addresses: z.array(Address).max(100),
+  addresses: z.array(Address).max(300),
   /**
    * The operator to use for evaluating transaction addresses.
    * "in" checks if an address is in the provided list.
@@ -128,9 +128,9 @@ export const EvmTypedAddressConditionSchema = z.object({
   /**
    * Array of EVM addresses to compare against.
    * Each address must be a 0x-prefixed 40-character hexadecimal string.
-   * Limited to a maximum of 100 addresses per condition.
+   * Limited to a maximum of 300 addresses per condition.
    */
-  addresses: z.array(Address).max(100),
+  addresses: z.array(Address).max(300),
   /**
    * The operator to use for evaluating addresses.
    * "in" checks if an address is in the provided list.
@@ -235,9 +235,9 @@ export const SignEvmTypedDataVerifyingContractCriterionSchema = z.object({
   /**
    * Array of EVM addresses allowed or disallowed as verifying contracts.
    * Each address must be a 0x-prefixed 40-character hexadecimal string.
-   * Limited to a maximum of 100 addresses per criterion.
+   * Limited to a maximum of 300 addresses per criterion.
    */
-  addresses: z.array(Address).max(100),
+  addresses: z.array(Address).max(300),
   /**
    * The operator to use for evaluating verifying contract addresses.
    * "in" checks if the verifying contract is in the provided list.

package/version.ts

@@ -1 +1 @@
-export const version = "1.26.0";
+export const version = "1.28.0";