@coinbase/cdp-sdk 0.0.0 → 1.0.1

package/dist/auth/utils/jwt.js

@@ -0,0 +1,235 @@
+"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.generateJwt = generateJwt;
+exports.generateWalletJwt = generateWalletJwt;
+const crypto = __importStar(require("crypto"));
+const crypto_1 = require("crypto");
+const jose_1 = require("jose");
+const errors_1 = require("../errors");
+/**
+ * Generates a JWT (also known as a Bearer token) for authenticating with Coinbase's REST APIs.
+ * Supports both EC (ES256) and Ed25519 (EdDSA) keys.
+ *
+ * @param options - The configuration options for generating the JWT
+ * @returns The generated JWT (Bearer token) string
+ * @throws {Error} If required parameters are missing, invalid, or if JWT signing fails
+ */
+async function generateJwt(options) {
+    // Validate required parameters
+    if (!options.apiKeyId) {
+        throw new Error("Key name is required");
+    }
+    if (!options.apiKeySecret) {
+        throw new Error("Private key is required");
+    }
+    if (!options.requestMethod || !options.requestHost || !options.requestPath) {
+        throw new Error("Request details (method, host, path) are required");
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const expiresIn = options.expiresIn || 120; // Default to 120 seconds if not specified
+    const uri = `${options.requestMethod} ${options.requestHost}${options.requestPath}`;
+    // Prepare the JWT payload
+    const claims = {
+        sub: options.apiKeyId,
+        iss: "cdp",
+        aud: ["cdp_service"],
+        uris: [uri],
+    };
+    // Generate random nonce for the header
+    const randomNonce = nonce();
+    // Determine if we're using EC or Edwards key based on the key format
+    if (isValidECKey(options.apiKeySecret)) {
+        return await buildECJWT(options.apiKeySecret, options.apiKeyId, claims, now, expiresIn, randomNonce);
+    }
+    else if (isValidEd25519Key(options.apiKeySecret)) {
+        return await buildEdwardsJWT(options.apiKeySecret, options.apiKeyId, claims, now, expiresIn, randomNonce);
+    }
+    else {
+        throw new Error("Invalid key format - must be either PEM EC key or base64 Ed25519 key");
+    }
+}
+/**
+ * Generates a wallet authentication JWT for the given API endpoint URL.
+ * Used for authenticating with specific endpoints that require wallet authentication.
+ *
+ * @param options - The configuration options for generating the JWT
+ * @returns The generated JWT (Bearer token) string
+ * @throws {UndefinedWalletSecretError} If the Wallet Secret is not defined.
+ * @throws {InvalidWalletSecretFormatError} If the private key is not in the correct format or signing fails.
+ */
+async function generateWalletJwt(options) {
+    if (!options.walletSecret) {
+        throw new errors_1.UndefinedWalletSecretError("Wallet Secret is not defined");
+    }
+    const uri = `${options.requestMethod} ${options.requestHost}${options.requestPath}`;
+    const now = Math.floor(Date.now() / 1000);
+    const claims = {
+        uris: [uri],
+    };
+    if (Object.keys(options.requestData).length > 0) {
+        claims.req = options.requestData;
+    }
+    try {
+        const ecKey = (0, crypto_1.createPrivateKey)({
+            key: options.walletSecret,
+            format: "der",
+            type: "pkcs8",
+            encoding: "base64",
+        });
+        return await new jose_1.SignJWT(claims)
+            .setProtectedHeader({ alg: "ES256", typ: "JWT" })
+            .setIssuedAt(now)
+            .setNotBefore(now)
+            .setJti(nonce())
+            .sign(ecKey);
+    }
+    catch (error) {
+        throw new errors_1.InvalidWalletSecretFormatError("Could not create the EC key: " + error);
+    }
+}
+/**
+ * Determines if a string could be a valid Ed25519 key
+ *
+ * @param str - The string to test
+ * @returns True if the string could be a valid Ed25519 key, false otherwise
+ */
+function isValidEd25519Key(str) {
+    try {
+        const decoded = Buffer.from(str, "base64");
+        return decoded.length === 64;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Determines if a string is a valid EC private key in PEM format
+ *
+ * @param str - The string to test
+ * @returns True if the string is a valid EC private key in PEM format
+ */
+function isValidECKey(str) {
+    try {
+        // Attempt to create a private key object - will throw if invalid
+        const key = (0, crypto_1.createPrivateKey)(str);
+        // Check if it's an EC key by examining its asymmetric key type
+        return key.asymmetricKeyType === "ec";
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Builds a JWT using an EC key.
+ *
+ * @param privateKey - The EC private key in PEM format
+ * @param keyName - The key name/ID
+ * @param claims - The JWT claims
+ * @param now - Current timestamp in seconds
+ * @param expiresIn - Number of seconds until the token expires
+ * @param nonce - Random nonce for the JWT header
+ * @returns A JWT token signed with an EC key
+ * @throws {Error} If key conversion, import, or signing fails
+ */
+async function buildECJWT(privateKey, keyName, claims, now, expiresIn, nonce) {
+    try {
+        // Convert to PKCS8 format
+        const keyObj = (0, crypto_1.createPrivateKey)(privateKey);
+        const pkcs8Key = keyObj.export({ type: "pkcs8", format: "pem" }).toString();
+        // Import the key for signing
+        const ecKey = await (0, jose_1.importPKCS8)(pkcs8Key, "ES256");
+        // Sign and return the JWT
+        return await new jose_1.SignJWT(claims)
+            .setProtectedHeader({ alg: "ES256", kid: keyName, typ: "JWT", nonce })
+            .setIssuedAt(Math.floor(now))
+            .setNotBefore(Math.floor(now))
+            .setExpirationTime(Math.floor(now + expiresIn))
+            .sign(ecKey);
+    }
+    catch (error) {
+        throw new Error(`Failed to generate EC JWT: ${error.message}`);
+    }
+}
+/**
+ * Builds a JWT using an Ed25519 key.
+ *
+ * @param privateKey - The Ed25519 private key in base64 format
+ * @param keyName - The key name/ID
+ * @param claims - The JWT claims
+ * @param now - Current timestamp in seconds
+ * @param expiresIn - Number of seconds until the token expires
+ * @param nonce - Random nonce for the JWT header
+ * @returns A JWT token using an Ed25519 key
+ * @throws {Error} If key parsing, import, or signing fails
+ */
+async function buildEdwardsJWT(privateKey, keyName, claims, now, expiresIn, nonce) {
+    try {
+        // Decode the base64 key (expecting 64 bytes: 32 for seed + 32 for public key)
+        const decoded = Buffer.from(privateKey, "base64");
+        if (decoded.length !== 64) {
+            throw new Error("Invalid Ed25519 key length");
+        }
+        const seed = decoded.subarray(0, 32);
+        const publicKey = decoded.subarray(32);
+        // Create JWK from the key components
+        const jwk = {
+            kty: "OKP",
+            crv: "Ed25519",
+            d: seed.toString("base64url"),
+            x: publicKey.toString("base64url"),
+        };
+        // Import the key for signing
+        const key = await (0, jose_1.importJWK)(jwk, "EdDSA");
+        // Sign and return the JWT
+        return await new jose_1.SignJWT(claims)
+            .setProtectedHeader({ alg: "EdDSA", kid: keyName, typ: "JWT", nonce })
+            .setIssuedAt(Math.floor(now))
+            .setNotBefore(Math.floor(now))
+            .setExpirationTime(Math.floor(now + expiresIn))
+            .sign(key);
+    }
+    catch (error) {
+        throw new Error(`Failed to generate Ed25519 JWT: ${error.message}`);
+    }
+}
+/**
+ * Generates a random nonce for the JWT.
+ *
+ * @returns {string} The generated nonce.
+ */
+function nonce() {
+    return crypto.randomBytes(16).toString("hex");
+}

package/dist/client/cdp.d.ts

@@ -0,0 +1,43 @@
+import { EvmClient } from "./evm";
+import { SolanaClient } from "./solana";
+interface CdpClientOptions {
+    /** The API key ID. */
+    apiKeyId: string;
+    /** The API key secret. */
+    apiKeySecret: string;
+    /** The wallet secret. */
+    walletSecret: string;
+    /** Whether to enable debugging. */
+    debugging?: boolean;
+    /** The host URL to connect to. */
+    basePath?: string;
+}
+/**
+ * The main client for interacting with the CDP API.
+ */
+export declare class CdpClient {
+    /** Namespace containing all EVM methods. */
+    evm: EvmClient;
+    /** Namespace containing all Solana methods. */
+    solana: SolanaClient;
+    /**
+     * The CdpClient is the main class for interacting with the CDP API.
+     *
+     * There are a few required parameters that are configured in the [CDP Portal](https://portal.cdp.coinbase.com/projects/api-keys):
+     * - **CDP Secret API Key** (`apiKeyId` & `apiKeySecret`): These are used to authenticate requests to the entire suite of
+     *   APIs offered on Coinbase Developer Platform.
+     *   [Read more about CDP API keys](https://docs.cdp.coinbase.com/get-started/docs/cdp-api-keys).
+     * - **Wallet Secret** (`walletSecret`): This secret is used specifically to authenticate requests to `POST`, and `DELETE`
+     *   endpoints in the EVM and Solana Account APIs.
+     *
+     * The CdpClient is namespaced by chain type: `evm` or `solana`.
+     *
+     * As an example, to create a new EVM account, use `cdp.evm.createAccount()`.
+     *
+     * To create a new Solana account, use `cdp.solana.createAccount()`.
+     *
+     * @param {CdpClientOptions} options - Configuration options for the CdpClient.
+     */
+    constructor(options: CdpClientOptions);
+}
+export {};

package/dist/client/cdp.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CdpClient = void 0;
+const openapi_client_1 = require("../openapi-client");
+const package_json_1 = require("../../package.json");
+const evm_1 = require("./evm");
+const solana_1 = require("./solana");
+/**
+ * The main client for interacting with the CDP API.
+ */
+class CdpClient {
+    /**
+     * The CdpClient is the main class for interacting with the CDP API.
+     *
+     * There are a few required parameters that are configured in the [CDP Portal](https://portal.cdp.coinbase.com/projects/api-keys):
+     * - **CDP Secret API Key** (`apiKeyId` & `apiKeySecret`): These are used to authenticate requests to the entire suite of
+     *   APIs offered on Coinbase Developer Platform.
+     *   [Read more about CDP API keys](https://docs.cdp.coinbase.com/get-started/docs/cdp-api-keys).
+     * - **Wallet Secret** (`walletSecret`): This secret is used specifically to authenticate requests to `POST`, and `DELETE`
+     *   endpoints in the EVM and Solana Account APIs.
+     *
+     * The CdpClient is namespaced by chain type: `evm` or `solana`.
+     *
+     * As an example, to create a new EVM account, use `cdp.evm.createAccount()`.
+     *
+     * To create a new Solana account, use `cdp.solana.createAccount()`.
+     *
+     * @param {CdpClientOptions} options - Configuration options for the CdpClient.
+     */
+    constructor(options) {
+        openapi_client_1.CdpOpenApiClient.configure({
+            ...options,
+            source: "sdk",
+            sourceVersion: package_json_1.version,
+        });
+        this.evm = new evm_1.EvmClient();
+        this.solana = new solana_1.SolanaClient();
+    }
+}
+exports.CdpClient = CdpClient;