@coinbase/cdp-sdk 0.0.0 → 1.0.0

package/dist/client/solana/solana.types.d.ts

@@ -0,0 +1,94 @@
+import { OpenApiSolanaMethods, SolanaAccount as OpenAPISolanaAccount } from "../../openapi-client";
+/**
+ * The SolanaClient type, where all OpenApiSolanaMethods methods are wrapped.
+ */
+export type SolanaClientInterface = Omit<typeof OpenApiSolanaMethods, "createSolanaAccount" | "getSolanaAccount" | "getSolanaAccountByName" | "listSolanaAccounts" | "requestSolanaFaucet" | "signSolanaMessage" | "signSolanaTransaction"> & {
+    createAccount: (options: CreateAccountOptions) => Promise<Account>;
+    getAccount: (options: GetAccountOptions) => Promise<Account>;
+    listAccounts: (options: ListAccountsOptions) => Promise<ListAccountsResult>;
+    requestFaucet: (options: RequestFaucetOptions) => Promise<SignatureResult>;
+    signMessage: (options: SignMessageOptions) => Promise<SignatureResult>;
+    signTransaction: (options: SignTransactionOptions) => Promise<SignatureResult>;
+};
+/**
+ * A Solana account.
+ */
+export type Account = OpenAPISolanaAccount;
+/**
+ * Options for creating a Solana account.
+ */
+export interface CreateAccountOptions {
+    /** The name of the account. */
+    name?: string;
+    /** The idempotency key. */
+    idempotencyKey?: string;
+}
+/**
+ * Options for getting a Solana account.
+ */
+export interface GetAccountOptions {
+    /** The address of the account. */
+    address?: string;
+    /** The name of the account. */
+    name?: string;
+}
+/**
+ * Options for listing Solana accounts.
+ */
+export interface ListAccountsOptions {
+    /** The page size. */
+    pageSize?: number;
+    /** The page token. */
+    pageToken?: string;
+}
+/**
+ * The result of listing Solana accounts.
+ */
+export interface ListAccountsResult {
+    /** The accounts. */
+    accounts: Account[];
+    /**
+     * The token for the next page of accounts, if any.
+     */
+    nextPageToken?: string;
+}
+/**
+ * Options for requesting funds from a Solana faucet.
+ */
+export interface RequestFaucetOptions {
+    /** The address of the account. */
+    address: string;
+    /** The token to request funds for. */
+    token: "sol" | "usdc";
+    /** The idempotency key. */
+    idempotencyKey?: string;
+}
+/**
+ * Options for signing a Solana message.
+ */
+export interface SignMessageOptions {
+    /** The address of the account. */
+    address: string;
+    /** The message to sign. */
+    message: string;
+    /** The idempotency key. */
+    idempotencyKey?: string;
+}
+/**
+ * Options for signing a Solana transaction.
+ */
+export interface SignTransactionOptions {
+    /** The address of the account. */
+    address: string;
+    /** The base64 encoded transaction to sign. */
+    transaction: string;
+    /** The idempotency key. */
+    idempotencyKey?: string;
+}
+/**
+ * A Solana signature result.
+ */
+export interface SignatureResult {
+    /** The signature. */
+    signature: string;
+}

package/dist/client/solana/solana.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+/**
+ * The URL to the Coinbase CDP API error docs page.
+ */
+export declare const ERROR_DOCS_PAGE_URL = "https://docs.cdp.coinbase.com/api-v2/docs/errors";

package/dist/constants.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ERROR_DOCS_PAGE_URL = void 0;
+/**
+ * The URL to the Coinbase CDP API error docs page.
+ */
+exports.ERROR_DOCS_PAGE_URL = "https://docs.cdp.coinbase.com/api-v2/docs/errors";

package/dist/errors.d.ts

@@ -0,0 +1,11 @@
+/**
+ * TimeoutError is thrown when an operation times out.
+ */
+export declare class TimeoutError extends Error {
+    /**
+     * Initializes a new TimeoutError instance.
+     *
+     * @param message - The error message.
+     */
+    constructor(message?: string);
+}

package/dist/errors.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeoutError = void 0;
+/**
+ * TimeoutError is thrown when an operation times out.
+ */
+class TimeoutError extends Error {
+    /**
+     * Initializes a new TimeoutError instance.
+     *
+     * @param message - The error message.
+     */
+    constructor(message = "Timeout Error") {
+        super(message);
+        this.name = "TimeoutError";
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, TimeoutError);
+        }
+    }
+}
+exports.TimeoutError = TimeoutError;

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import "./analytics";
+export { CdpClient } from "./client/cdp";
+export { EvmServerAccount, EvmSmartAccount } from "./accounts/types";

package/dist/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpClient = void 0;
+require("./analytics");
+var cdp_1 = require("./client/cdp");
+Object.defineProperty(exports, "CdpClient", { enumerable: true, get: function () { return cdp_1.CdpClient; } });

package/dist/openapi-client/cdpApiClient.d.ts

@@ -0,0 +1,50 @@
+import { AxiosRequestConfig } from "axios";
+/**
+ * The options for the CDP API.
+ */
+export type CdpOptions = {
+    /**
+     * The API key ID or the legacy API key name.
+     *
+     * Examples:
+     *  ID format: 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+     *  Legacy name format: 'organizations/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx/apiKeys/xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
+     */
+    apiKeyId: string;
+    /**
+     * The API key secret, using the Ed25519 or legacy EC key format.
+     *
+     * Examples:
+     *  Ed25519 key: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx=='
+     *  EC key: '-----BEGIN EC PRIVATE KEY-----\n...\n...\n...==\n-----END EC PRIVATE KEY-----\n'
+     */
+    apiKeySecret: string;
+    /** The Wallet Secret. Only needed if calling certain Wallet APIs. */
+    walletSecret?: string;
+    /** If true, logs API requests and responses to the console. */
+    debugging?: boolean;
+    /** The base path for the API. */
+    basePath?: string;
+    /** The source for the API request, used for analytics. Defaults to `typescript-client`. */
+    source?: string;
+    /** The version of the source for the API request, used for analytics. */
+    sourceVersion?: string;
+    /** Optional expiration time in seconds (defaults to 120) */
+    expiresIn?: number;
+};
+/**
+ * Configures the CDP client with the given options.
+ *
+ * @param {CdpOptions} options - The CDP options.
+ */
+export declare const configure: (options: CdpOptions) => void;
+/**
+ * Mutates the given Axios request configuration to add the CDP API key signature
+ * to the request headers.
+ *
+ * @param {AxiosRequestConfig} config - The Axios request configuration.
+ * @param idempotencyKey - The idempotency key.
+ * @returns {Promise<T>} A promise that resolves to the response data.
+ * @throws {APIError} If the request fails.
+ */
+export declare const cdpApiClient: <T>(config: AxiosRequestConfig, idempotencyKey?: string) => Promise<T>;

package/dist/openapi-client/cdpApiClient.js

@@ -0,0 +1,146 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cdpApiClient = exports.configure = void 0;
+const axios_1 = __importStar(require("axios"));
+const axios_2 = require("../auth/hooks/axios");
+const errors_1 = require("./errors");
+const constants_1 = require("../constants");
+let axiosInstance;
+/**
+ * Configures the CDP client with the given options.
+ *
+ * @param {CdpOptions} options - The CDP options.
+ */
+const configure = (options) => {
+    axiosInstance = axios_1.default.create({
+        baseURL: options.basePath || "https://api.cdp.coinbase.com/platform",
+    });
+    axiosInstance = (0, axios_2.withAuth)(axiosInstance, {
+        apiKeyId: options.apiKeyId,
+        apiKeySecret: options.apiKeySecret,
+        source: options.source || "sdk-openapi-client",
+        sourceVersion: options.sourceVersion,
+        walletSecret: options.walletSecret,
+        expiresIn: options.expiresIn,
+        debug: options.debugging,
+    });
+};
+exports.configure = configure;
+/**
+ * Adds an idempotency key to request config if provided
+ *
+ * @param config - The Axios request configuration.
+ * @param idempotencyKey - The idempotency key.
+ * @returns The Axios request configuration with the idempotency key.
+ */
+const addIdempotencyKey = (config, idempotencyKey) => {
+    if (!idempotencyKey) {
+        return config;
+    }
+    return {
+        ...config,
+        headers: {
+            ...(config.headers || {}),
+            "X-Idempotency-Key": idempotencyKey,
+        },
+    };
+};
+/**
+ * Mutates the given Axios request configuration to add the CDP API key signature
+ * to the request headers.
+ *
+ * @param {AxiosRequestConfig} config - The Axios request configuration.
+ * @param idempotencyKey - The idempotency key.
+ * @returns {Promise<T>} A promise that resolves to the response data.
+ * @throws {APIError} If the request fails.
+ */
+const cdpApiClient = async (config, idempotencyKey) => {
+    validateCall(config);
+    // Add idempotency key to the request headers if provided
+    const configWithIdempotencyKey = addIdempotencyKey(config, idempotencyKey);
+    try {
+        const response = await axiosInstance(configWithIdempotencyKey);
+        return response.data;
+    }
+    catch (error) {
+        if (axios_1.default.isAxiosError(error) && error.response) {
+            if ((0, errors_1.isOpenAPIError)(error.response.data)) {
+                throw new errors_1.APIError(error.response.status, error.response.data.errorType, error.response.data.errorMessage, error.response.data.correlationId, error.response.data.errorLink);
+            }
+            else {
+                const statusCode = error.response.status;
+                switch (statusCode) {
+                    case 401:
+                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.unauthorized, "Unauthorized.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}#unauthorized`);
+                    case 404:
+                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.not_found, "API not found.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}#not_found`);
+                    case 502:
+                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.bad_gateway, "Bad gateway.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
+                    case 503:
+                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.service_unavailable, "Service unavailable. Please try again later.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
+                    default:
+                        throw new errors_1.APIError(statusCode, errors_1.HttpErrorType.unexpected_error, "An unexpected error occurred.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
+                }
+            }
+        }
+        else if (axios_1.default.isAxiosError(error) && error.request) {
+            throw new errors_1.APIError(axios_1.HttpStatusCode.ServiceUnavailable, errors_1.HttpErrorType.service_unavailable, "Network error, unable to reach the service.", undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
+        }
+        else {
+            throw new errors_1.APIError(axios_1.HttpStatusCode.InternalServerError, errors_1.HttpErrorType.unexpected_error, error instanceof Error
+                ? error.message
+                : `An unexpected error occurred: ${JSON.stringify(error, Object.getOwnPropertyNames(error))}`, undefined, `${constants_1.ERROR_DOCS_PAGE_URL}`);
+        }
+    }
+};
+exports.cdpApiClient = cdpApiClient;
+/**
+ * Validates the call to the cdpApiClient.
+ *
+ * @param {AxiosRequestConfig} config - The Axios request configuration.
+ * @throws {Error} If the call is not valid.
+ */
+const validateCall = (config) => {
+    if (!axiosInstance.getUri() || axiosInstance.getUri() === "") {
+        throw new Error("CDP client URI not configured. Call configure() first.");
+    }
+    if (!config.url || config.url === "") {
+        throw new Error("AxiosRequestConfig URL is empty. This should never happen.");
+    }
+    if (!config.method || config.method === "") {
+        throw new Error("AxiosRequestConfig method is empty. This should never happen.");
+    }
+};

package/dist/openapi-client/errors.d.ts

@@ -0,0 +1,53 @@
+import { Error as OpenAPIError, ErrorType as OpenAPIErrorType } from "./generated/coinbaseDeveloperPlatformAPIs.schemas";
+export declare const HttpErrorType: {
+    readonly unexpected_error: "unexpected_error";
+    readonly unauthorized: "unauthorized";
+    readonly not_found: "not_found";
+    readonly bad_gateway: "bad_gateway";
+    readonly service_unavailable: "service_unavailable";
+};
+export type HttpErrorType = (typeof HttpErrorType)[keyof typeof HttpErrorType];
+/**
+ * Extended error codes that include both OpenAPI errors and network errors
+ */
+export type APIErrorType = OpenAPIErrorType | HttpErrorType;
+/**
+ * Extended API error that encompasses both OpenAPI errors and other API-related errors
+ */
+export declare class APIError extends Error {
+    statusCode: number;
+    errorType: APIErrorType;
+    errorMessage: string;
+    correlationId?: string;
+    errorLink?: string;
+    /**
+     * Constructor for the APIError class
+     *
+     * @param statusCode - The HTTP status code
+     * @param errorType - The type of error
+     * @param errorMessage - The error message
+     * @param correlationId - The correlation ID
+     * @param errorLink - URL to documentation about this error
+     */
+    constructor(statusCode: number, errorType: APIErrorType, errorMessage: string, correlationId?: string, errorLink?: string);
+    /**
+     * Convert the error to a JSON object, excluding undefined properties
+     *
+     * @returns The error as a JSON object
+     */
+    toJSON(): {
+        errorLink?: string | undefined;
+        correlationId?: string | undefined;
+        name: string;
+        statusCode: number;
+        errorType: APIErrorType;
+        errorMessage: string;
+    };
+}
+/**
+ * Type guard to check if an object is an OpenAPIError
+ *
+ * @param obj - The object to check
+ * @returns True if the object is an OpenAPIError
+ */
+export declare function isOpenAPIError(obj: unknown): obj is OpenAPIError;

package/dist/openapi-client/errors.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.APIError = exports.HttpErrorType = void 0;
+exports.isOpenAPIError = isOpenAPIError;
+exports.HttpErrorType = {
+    unexpected_error: "unexpected_error",
+    unauthorized: "unauthorized",
+    not_found: "not_found",
+    bad_gateway: "bad_gateway",
+    service_unavailable: "service_unavailable",
+};
+/**
+ * Extended API error that encompasses both OpenAPI errors and other API-related errors
+ */
+class APIError extends Error {
+    /**
+     * Constructor for the APIError class
+     *
+     * @param statusCode - The HTTP status code
+     * @param errorType - The type of error
+     * @param errorMessage - The error message
+     * @param correlationId - The correlation ID
+     * @param errorLink - URL to documentation about this error
+     */
+    constructor(statusCode, errorType, errorMessage, correlationId, errorLink) {
+        super(errorMessage);
+        this.name = "APIError";
+        this.statusCode = statusCode;
+        this.errorType = errorType;
+        this.errorMessage = errorMessage;
+        // Only set correlationId if it's defined
+        if (correlationId !== undefined) {
+            this.correlationId = correlationId;
+        }
+        // Only set errorLink if it's defined
+        if (errorLink !== undefined) {
+            this.errorLink = errorLink;
+        }
+    }
+    /**
+     * Convert the error to a JSON object, excluding undefined properties
+     *
+     * @returns The error as a JSON object
+     */
+    toJSON() {
+        return {
+            name: this.name,
+            statusCode: this.statusCode,
+            errorType: this.errorType,
+            errorMessage: this.errorMessage,
+            ...(this.correlationId && { correlationId: this.correlationId }),
+            ...(this.errorLink && { errorLink: this.errorLink }),
+        };
+    }
+}
+exports.APIError = APIError;
+/**
+ * Type guard to check if an object is an OpenAPIError
+ *
+ * @param obj - The object to check
+ * @returns True if the object is an OpenAPIError
+ */
+function isOpenAPIError(obj) {
+    return (obj !== null &&
+        typeof obj === "object" &&
+        "errorType" in obj &&
+        typeof obj.errorType === "string" &&
+        "errorMessage" in obj &&
+        typeof obj.errorMessage === "string");
+}