@bitgo-beta/sdk-hmac 1.0.1-beta.102 → 1.0.1-beta.1021

package/dist/src/hmacv4.js

@@ -0,0 +1,274 @@
+"use strict";
+/**
+ * @prettier
+ *
+ * V4 HMAC Authentication Module
+ *
+ * This module implements the v4 authentication scheme which uses a canonical
+ * preimage construction with newline-separated fields and body hashing.
+ *
+ * Key differences from v2/v3:
+ * - Separator: newline (\n) instead of pipe (|)
+ * - Body: SHA256 hash of raw bytes instead of actual body content
+ * - Timestamp: seconds instead of milliseconds
+ * - New field: authRequestId for request tracking
+ * - Trailing newline in preimage
+ * - Support for x-original-* headers (proxy scenarios)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateV4Preimage = calculateV4Preimage;
+exports.calculateBodyHash = calculateBodyHash;
+exports.calculateV4RequestHmac = calculateV4RequestHmac;
+exports.calculateV4RequestHeaders = calculateV4RequestHeaders;
+exports.calculateV4ResponsePreimage = calculateV4ResponsePreimage;
+exports.verifyV4Response = verifyV4Response;
+exports.getPathWithQuery = getPathWithQuery;
+exports.getMethod = getMethod;
+const crypto_1 = require("crypto");
+const util_1 = require("./util");
+/**
+ * Build canonical preimage for v4 authentication.
+ *
+ * The preimage is constructed as newline-separated values with a trailing newline:
+ * ```
+ * {timestampSec}
+ * {METHOD}
+ * {pathWithQuery}
+ * {bodyHashHex}
+ * {authRequestId}
+ * ```
+ *
+ * This function normalizes the HTTP method to uppercase and handles the
+ * legacy 'del' method conversion to 'DELETE'.
+ *
+ * @param options - The preimage components
+ * @returns Newline-separated canonical preimage string with trailing newline
+ *
+ * @example
+ * ```typescript
+ * const preimage = calculateV4Preimage({
+ *   timestampSec: 1761100000,
+ *   method: 'post',
+ *   pathWithQuery: '/v2/wallets/transfer?foo=bar',
+ *   bodyHashHex: '0d5e3b7a8f9c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e',
+ *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',
+ * });
+ *
+ * // Result:
+ * // "1761100000\nPOST\n/v2/wallets/transfer?foo=bar\n0d5e3b...d6e\n1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e\n"
+ * ```
+ */
+function calculateV4Preimage({ timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, }) {
+    const normalizedMethod = (0, util_1.normalizeMethod)(method);
+    // Build newline-separated preimage with trailing newline
+    const components = [timestampSec.toString(), normalizedMethod, pathWithQuery, bodyHashHex, authRequestId];
+    return components.join('\n') + '\n';
+}
+/**
+ * Calculate SHA256 hash of body and return as lowercase hex string.
+ *
+ * This is used to compute the bodyHashHex field for v4 authentication.
+ * The hash is computed over the raw bytes of the request body, ensuring
+ * that the exact bytes sent over the wire are used for signature calculation.
+ *
+ * Accepts common byte representations for Node.js and browser environments,
+ * including Uint8Array and ArrayBuffer for Fetch API compatibility.
+ *
+ * @param body - Raw request body (string, Buffer, Uint8Array, or ArrayBuffer)
+ * @returns Lowercase hex SHA256 hash (64 characters)
+ *
+ * @example
+ * ```typescript
+ * // Node.js with Buffer
+ * const hash1 = calculateBodyHash(Buffer.from('{"address":"tb1q...","amount":100000}'));
+ *
+ * // Browser with Uint8Array
+ * const hash2 = calculateBodyHash(new TextEncoder().encode('{"address":"tb1q..."}'));
+ *
+ * // Browser with ArrayBuffer
+ * const hash3 = calculateBodyHash(await response.arrayBuffer());
+ *
+ * // All return: '0d5e3b7a8f...' (64 character hex string)
+ * ```
+ */
+function calculateBodyHash(body) {
+    return (0, util_1.sha256Hex)(body);
+}
+/**
+ * Calculate the HMAC-SHA256 signature for a v4 HTTP request.
+ *
+ * This function:
+ * 1. Builds the canonical preimage from the provided options
+ * 2. Computes HMAC-SHA256 of the preimage using the raw access token
+ *
+ * @param options - Request parameters and raw access token
+ * @returns Lowercase hex HMAC-SHA256 signature
+ *
+ * @example
+ * ```typescript
+ * const hmac = calculateV4RequestHmac({
+ *   timestampSec: 1761100000,
+ *   method: 'POST',
+ *   pathWithQuery: '/v2/wallets/transfer',
+ *   bodyHashHex: '0d5e3b...',
+ *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',
+ *   rawToken: 'your-token',
+ * });
+ * ```
+ */
+function calculateV4RequestHmac({ timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, rawToken, }) {
+    const preimage = calculateV4Preimage({
+        timestampSec,
+        method,
+        pathWithQuery,
+        bodyHashHex,
+        authRequestId,
+    });
+    return (0, util_1.createHmacWithSha256)(rawToken, preimage);
+}
+/**
+ * Generate all headers required for v4 authenticated requests.
+ *
+ * This is a convenience function that:
+ * 1. Generates the current timestamp (in seconds)
+ * 2. Calculates the body hash from raw bytes
+ * 3. Computes the HMAC signature
+ * 4. Returns all values needed for request headers
+ *
+ * @param options - Request parameters including raw body and raw token
+ * @returns Object containing all v4 authentication header values
+ *
+ * @example
+ * ```typescript
+ * const headers = calculateV4RequestHeaders({
+ *   method: 'POST',
+ *   pathWithQuery: '/v2/wallets/transfer?foo=bar',
+ *   rawBody: Buffer.from('{"address":"tb1q..."}'),
+ *   rawToken: 'your-token',
+ *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',
+ * });
+ *
+ * // Use headers to set:
+ * // - X-Request-Timestamp: headers.timestampSec
+ * // - X-Signature: headers.hmac
+ * // - X-Content-SHA256: headers.bodyHashHex
+ * // - X-Auth-Request-Id: headers.authRequestId
+ * ```
+ */
+function calculateV4RequestHeaders({ method, pathWithQuery, rawBody, rawToken, authRequestId, }) {
+    const timestampSec = (0, util_1.getTimestampSec)();
+    const bodyHashHex = calculateBodyHash(rawBody);
+    const hmac = calculateV4RequestHmac({
+        timestampSec,
+        method,
+        pathWithQuery,
+        bodyHashHex,
+        authRequestId,
+        rawToken,
+    });
+    return {
+        hmac,
+        timestampSec,
+        bodyHashHex,
+        authRequestId,
+    };
+}
+/**
+ * Build canonical preimage for v4 response verification.
+ *
+ * Response preimage includes the status code and uses the same format:
+ * ```
+ * {timestampSec}
+ * {METHOD}
+ * {pathWithQuery}
+ * {statusCode}
+ * {bodyHashHex}
+ * {authRequestId}
+ * ```
+ *
+ * @param options - Response verification parameters
+ * @returns Newline-separated canonical preimage string with trailing newline
+ */
+function calculateV4ResponsePreimage({ timestampSec, method, pathWithQuery, statusCode, bodyHashHex, authRequestId, }) {
+    const normalizedMethod = (0, util_1.normalizeMethod)(method);
+    const components = [
+        timestampSec.toString(),
+        normalizedMethod,
+        pathWithQuery,
+        statusCode.toString(),
+        bodyHashHex,
+        authRequestId,
+    ];
+    return components.join('\n') + '\n';
+}
+/**
+ * Verify the HMAC signature of a v4 HTTP response.
+ *
+ * This function:
+ * 1. Reconstructs the canonical preimage from response data
+ * 2. Calculates the expected HMAC
+ * 3. Compares with the received HMAC
+ * 4. Checks if the timestamp is within the validity window
+ *
+ * The validity window is:
+ * - 5 minutes backwards (to account for clock skew and network latency)
+ * - 1 minute forwards (to account for minor clock differences)
+ *
+ * @param options - Response data and raw token for verification
+ * @returns Verification result including validity and diagnostic info
+ */
+function verifyV4Response({ hmac, timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, statusCode, rawToken, }) {
+    // Build the response preimage
+    const preimage = calculateV4ResponsePreimage({
+        timestampSec,
+        method,
+        pathWithQuery,
+        statusCode,
+        bodyHashHex,
+        authRequestId,
+    });
+    // Calculate expected HMAC
+    const expectedHmac = (0, util_1.createHmacWithSha256)(rawToken, preimage);
+    // Use constant-time comparison to prevent timing side-channel attacks
+    const hmacBuffer = Buffer.from(hmac, 'hex');
+    const expectedHmacBuffer = Buffer.from(expectedHmac, 'hex');
+    const isHmacValid = hmacBuffer.length === expectedHmacBuffer.length && (0, crypto_1.timingSafeEqual)(hmacBuffer, expectedHmacBuffer);
+    // Check timestamp validity window
+    const nowSec = (0, util_1.getTimestampSec)();
+    const backwardValidityWindowSec = 5 * 60; // 5 minutes
+    const forwardValidityWindowSec = 1 * 60; // 1 minute
+    const isInResponseValidityWindow = timestampSec >= nowSec - backwardValidityWindowSec && timestampSec <= nowSec + forwardValidityWindowSec;
+    return {
+        isValid: isHmacValid,
+        expectedHmac,
+        preimage,
+        isInResponseValidityWindow,
+        verificationTime: Date.now(),
+    };
+}
+/**
+ * Extract path with query from x-original-uri header or request URL.
+ * Always canonicalizes to pathname + search to handle absolute URLs.
+ *
+ * @param xOriginalUri - Value of x-original-uri header (if present)
+ * @param requestUrl - The actual request URL
+ * @returns The canonical path with query to use for preimage calculation
+ *
+ */
+function getPathWithQuery(xOriginalUri, requestUrl) {
+    // Prefer x-original-uri if available (proxy scenario)
+    const rawPath = xOriginalUri ?? requestUrl;
+    return (0, util_1.extractPathWithQuery)(rawPath);
+}
+/**
+ * Get method from x-original-method header or actual request method.
+ *
+ * @param xOriginalMethod - Value of x-original-method header (if present)
+ * @param requestMethod - The actual request method
+ * @returns The method to use for preimage calculation
+ */
+function getMethod(xOriginalMethod, requestMethod) {
+    // Prefer x-original-method if available (proxy scenario)
+    return xOriginalMethod ?? requestMethod;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hmacv4.js","sourceRoot":"","sources":["../../src/hmacv4.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * V4 HMAC Authentication Module\n *\n * This module implements the v4 authentication scheme which uses a canonical\n * preimage construction with newline-separated fields and body hashing.\n *\n * Key differences from v2/v3:\n * - Separator: newline (\\n) instead of pipe (|)\n * - Body: SHA256 hash of raw bytes instead of actual body content\n * - Timestamp: seconds instead of milliseconds\n * - New field: authRequestId for request tracking\n * - Trailing newline in preimage\n * - Support for x-original-* headers (proxy scenarios)\n */\n\nimport { timingSafeEqual } from 'crypto';\nimport {\n  createHmacWithSha256,\n  sha256Hex,\n  normalizeMethod,\n  getTimestampSec,\n  extractPathWithQuery,\n  type HashableData,\n} from './util';\nimport {\n  CalculateV4PreimageOptions,\n  CalculateV4RequestHmacOptions,\n  CalculateV4RequestHeadersOptions,\n  V4RequestHeaders,\n  VerifyV4ResponseOptions,\n  VerifyV4ResponseInfo,\n} from './types';\n\n/**\n * Build canonical preimage for v4 authentication.\n *\n * The preimage is constructed as newline-separated values with a trailing newline:\n * ```\n * {timestampSec}\n * {METHOD}\n * {pathWithQuery}\n * {bodyHashHex}\n * {authRequestId}\n * ```\n *\n * This function normalizes the HTTP method to uppercase and handles the\n * legacy 'del' method conversion to 'DELETE'.\n *\n * @param options - The preimage components\n * @returns Newline-separated canonical preimage string with trailing newline\n *\n * @example\n * ```typescript\n * const preimage = calculateV4Preimage({\n *   timestampSec: 1761100000,\n *   method: 'post',\n *   pathWithQuery: '/v2/wallets/transfer?foo=bar',\n *   bodyHashHex: '0d5e3b7a8f9c1d2e3f4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6e',\n *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',\n * });\n *\n * // Result:\n * // \"1761100000\\nPOST\\n/v2/wallets/transfer?foo=bar\\n0d5e3b...d6e\\n1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e\\n\"\n * ```\n */\nexport function calculateV4Preimage({\n  timestampSec,\n  method,\n  pathWithQuery,\n  bodyHashHex,\n  authRequestId,\n}: CalculateV4PreimageOptions): string {\n  const normalizedMethod = normalizeMethod(method);\n\n  // Build newline-separated preimage with trailing newline\n  const components = [timestampSec.toString(), normalizedMethod, pathWithQuery, bodyHashHex, authRequestId];\n\n  return components.join('\\n') + '\\n';\n}\n\n/**\n * Calculate SHA256 hash of body and return as lowercase hex string.\n *\n * This is used to compute the bodyHashHex field for v4 authentication.\n * The hash is computed over the raw bytes of the request body, ensuring\n * that the exact bytes sent over the wire are used for signature calculation.\n *\n * Accepts common byte representations for Node.js and browser environments,\n * including Uint8Array and ArrayBuffer for Fetch API compatibility.\n *\n * @param body - Raw request body (string, Buffer, Uint8Array, or ArrayBuffer)\n * @returns Lowercase hex SHA256 hash (64 characters)\n *\n * @example\n * ```typescript\n * // Node.js with Buffer\n * const hash1 = calculateBodyHash(Buffer.from('{\"address\":\"tb1q...\",\"amount\":100000}'));\n *\n * // Browser with Uint8Array\n * const hash2 = calculateBodyHash(new TextEncoder().encode('{\"address\":\"tb1q...\"}'));\n *\n * // Browser with ArrayBuffer\n * const hash3 = calculateBodyHash(await response.arrayBuffer());\n *\n * // All return: '0d5e3b7a8f...' (64 character hex string)\n * ```\n */\nexport function calculateBodyHash(body: HashableData): string {\n  return sha256Hex(body);\n}\n\n/**\n * Calculate the HMAC-SHA256 signature for a v4 HTTP request.\n *\n * This function:\n * 1. Builds the canonical preimage from the provided options\n * 2. Computes HMAC-SHA256 of the preimage using the raw access token\n *\n * @param options - Request parameters and raw access token\n * @returns Lowercase hex HMAC-SHA256 signature\n *\n * @example\n * ```typescript\n * const hmac = calculateV4RequestHmac({\n *   timestampSec: 1761100000,\n *   method: 'POST',\n *   pathWithQuery: '/v2/wallets/transfer',\n *   bodyHashHex: '0d5e3b...',\n *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',\n *   rawToken: 'your-token',\n * });\n * ```\n */\nexport function calculateV4RequestHmac({\n  timestampSec,\n  method,\n  pathWithQuery,\n  bodyHashHex,\n  authRequestId,\n  rawToken,\n}: CalculateV4RequestHmacOptions): string {\n  const preimage = calculateV4Preimage({\n    timestampSec,\n    method,\n    pathWithQuery,\n    bodyHashHex,\n    authRequestId,\n  });\n\n  return createHmacWithSha256(rawToken, preimage);\n}\n\n/**\n * Generate all headers required for v4 authenticated requests.\n *\n * This is a convenience function that:\n * 1. Generates the current timestamp (in seconds)\n * 2. Calculates the body hash from raw bytes\n * 3. Computes the HMAC signature\n * 4. Returns all values needed for request headers\n *\n * @param options - Request parameters including raw body and raw token\n * @returns Object containing all v4 authentication header values\n *\n * @example\n * ```typescript\n * const headers = calculateV4RequestHeaders({\n *   method: 'POST',\n *   pathWithQuery: '/v2/wallets/transfer?foo=bar',\n *   rawBody: Buffer.from('{\"address\":\"tb1q...\"}'),\n *   rawToken: 'your-token',\n *   authRequestId: '1b7a1d2b-7a2f-4e4b-a1f8-c2a5a0f84e3e',\n * });\n *\n * // Use headers to set:\n * // - X-Request-Timestamp: headers.timestampSec\n * // - X-Signature: headers.hmac\n * // - X-Content-SHA256: headers.bodyHashHex\n * // - X-Auth-Request-Id: headers.authRequestId\n * ```\n */\nexport function calculateV4RequestHeaders({\n  method,\n  pathWithQuery,\n  rawBody,\n  rawToken,\n  authRequestId,\n}: CalculateV4RequestHeadersOptions): V4RequestHeaders {\n  const timestampSec = getTimestampSec();\n  const bodyHashHex = calculateBodyHash(rawBody);\n\n  const hmac = calculateV4RequestHmac({\n    timestampSec,\n    method,\n    pathWithQuery,\n    bodyHashHex,\n    authRequestId,\n    rawToken,\n  });\n\n  return {\n    hmac,\n    timestampSec,\n    bodyHashHex,\n    authRequestId,\n  };\n}\n\n/**\n * Build canonical preimage for v4 response verification.\n *\n * Response preimage includes the status code and uses the same format:\n * ```\n * {timestampSec}\n * {METHOD}\n * {pathWithQuery}\n * {statusCode}\n * {bodyHashHex}\n * {authRequestId}\n * ```\n *\n * @param options - Response verification parameters\n * @returns Newline-separated canonical preimage string with trailing newline\n */\nexport function calculateV4ResponsePreimage({\n  timestampSec,\n  method,\n  pathWithQuery,\n  statusCode,\n  bodyHashHex,\n  authRequestId,\n}: Omit<VerifyV4ResponseOptions, 'hmac' | 'rawToken'>): string {\n  const normalizedMethod = normalizeMethod(method);\n\n  const components = [\n    timestampSec.toString(),\n    normalizedMethod,\n    pathWithQuery,\n    statusCode.toString(),\n    bodyHashHex,\n    authRequestId,\n  ];\n\n  return components.join('\\n') + '\\n';\n}\n\n/**\n * Verify the HMAC signature of a v4 HTTP response.\n *\n * This function:\n * 1. Reconstructs the canonical preimage from response data\n * 2. Calculates the expected HMAC\n * 3. Compares with the received HMAC\n * 4. Checks if the timestamp is within the validity window\n *\n * The validity window is:\n * - 5 minutes backwards (to account for clock skew and network latency)\n * - 1 minute forwards (to account for minor clock differences)\n *\n * @param options - Response data and raw token for verification\n * @returns Verification result including validity and diagnostic info\n */\nexport function verifyV4Response({\n  hmac,\n  timestampSec,\n  method,\n  pathWithQuery,\n  bodyHashHex,\n  authRequestId,\n  statusCode,\n  rawToken,\n}: VerifyV4ResponseOptions): VerifyV4ResponseInfo {\n  // Build the response preimage\n  const preimage = calculateV4ResponsePreimage({\n    timestampSec,\n    method,\n    pathWithQuery,\n    statusCode,\n    bodyHashHex,\n    authRequestId,\n  });\n\n  // Calculate expected HMAC\n  const expectedHmac = createHmacWithSha256(rawToken, preimage);\n\n  // Use constant-time comparison to prevent timing side-channel attacks\n  const hmacBuffer = Buffer.from(hmac, 'hex');\n  const expectedHmacBuffer = Buffer.from(expectedHmac, 'hex');\n  const isHmacValid =\n    hmacBuffer.length === expectedHmacBuffer.length && timingSafeEqual(hmacBuffer, expectedHmacBuffer);\n\n  // Check timestamp validity window\n  const nowSec = getTimestampSec();\n  const backwardValidityWindowSec = 5 * 60; // 5 minutes\n  const forwardValidityWindowSec = 1 * 60; // 1 minute\n  const isInResponseValidityWindow =\n    timestampSec >= nowSec - backwardValidityWindowSec && timestampSec <= nowSec + forwardValidityWindowSec;\n\n  return {\n    isValid: isHmacValid,\n    expectedHmac,\n    preimage,\n    isInResponseValidityWindow,\n    verificationTime: Date.now(),\n  };\n}\n\n/**\n * Extract path with query from x-original-uri header or request URL.\n * Always canonicalizes to pathname + search to handle absolute URLs.\n *\n * @param xOriginalUri - Value of x-original-uri header (if present)\n * @param requestUrl - The actual request URL\n * @returns The canonical path with query to use for preimage calculation\n *\n */\nexport function getPathWithQuery(xOriginalUri: string | undefined, requestUrl: string): string {\n  // Prefer x-original-uri if available (proxy scenario)\n  const rawPath = xOriginalUri ?? requestUrl;\n  return extractPathWithQuery(rawPath);\n}\n\n/**\n * Get method from x-original-method header or actual request method.\n *\n * @param xOriginalMethod - Value of x-original-method header (if present)\n * @param requestMethod - The actual request method\n * @returns The method to use for preimage calculation\n */\nexport function getMethod(xOriginalMethod: string | undefined, requestMethod: string): string {\n  // Prefer x-original-method if available (proxy scenario)\n  return xOriginalMethod ?? requestMethod;\n}\n"]}

package/dist/src/index.d.ts

@@ -1,3 +1,6 @@
 export * from './hmac';
+export * from './hmacv4';
+export * from './util';
 export * from './types';
+export * from './defaultStrategy';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,QAAQ,CAAC;AACvB,cAAc,UAAU,CAAC;AACzB,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC;AACxB,cAAc,mBAAmB,CAAC"}

package/dist/src/index.js

@@ -15,5 +15,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./hmac"), exports);
+__exportStar(require("./hmacv4"), exports);
+__exportStar(require("./util"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlDQUF1QjtBQUN2QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2htYWMnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=
+__exportStar(require("./defaultStrategy"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlDQUF1QjtBQUN2QiwyQ0FBeUI7QUFDekIseUNBQXVCO0FBQ3ZCLDBDQUF3QjtBQUN4QixvREFBa0MiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2htYWMnO1xuZXhwb3J0ICogZnJvbSAnLi9obWFjdjQnO1xuZXhwb3J0ICogZnJvbSAnLi91dGlsJztcbmV4cG9ydCAqIGZyb20gJy4vdHlwZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9kZWZhdWx0U3RyYXRlZ3knO1xuIl19

package/dist/src/indexedDbTokenStore.d.ts

@@ -0,0 +1,12 @@
+import type { CryptoSigning, ITokenStore } from './types';
+/**
+ * Persists {@link CryptoSigning} material in the browser's IndexedDB.
+ * The raw bearer token is never stored — only the non-extractable CryptoKey
+ * and the SHA-256 token hash are persisted via the structured clone algorithm.
+ */
+export declare class IndexedDbTokenStore implements ITokenStore {
+    save(signing: CryptoSigning): Promise<void>;
+    load(): Promise<CryptoSigning | null>;
+    remove(): Promise<void>;
+}
+//# sourceMappingURL=indexedDbTokenStore.d.ts.map

package/dist/src/indexedDbTokenStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indexedDbTokenStore.d.ts","sourceRoot":"","sources":["../../src/indexedDbTokenStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAwE1D;;;;GAIG;AACH,qBAAa,mBAAoB,YAAW,WAAW;IAC/C,IAAI,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAI3C,IAAI,IAAI,OAAO,CAAC,aAAa,GAAG,IAAI,CAAC;IAIrC,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9B"}

package/dist/src/indexedDbTokenStore.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexedDbTokenStore = void 0;
+const CRYPTO_DB_NAME = 'bitgo-auth';
+const CRYPTO_STORE_NAME = 'crypto-signing';
+const CRYPTO_RECORD_KEY = 'current';
+function hasIndexedDB() {
+    return typeof indexedDB !== 'undefined';
+}
+function openCryptoDb() {
+    return new Promise((resolve, reject) => {
+        const request = indexedDB.open(CRYPTO_DB_NAME, 1);
+        request.onupgradeneeded = () => {
+            const db = request.result;
+            if (!db.objectStoreNames.contains(CRYPTO_STORE_NAME)) {
+                db.createObjectStore(CRYPTO_STORE_NAME);
+            }
+        };
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+}
+async function withDb(fn) {
+    const db = await openCryptoDb();
+    try {
+        return await fn(db);
+    }
+    finally {
+        db.close();
+    }
+}
+async function persistCryptoSigning(signing) {
+    if (!hasIndexedDB())
+        return;
+    await withDb((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(CRYPTO_STORE_NAME, 'readwrite');
+        tx.objectStore(CRYPTO_STORE_NAME).put(signing, CRYPTO_RECORD_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    }));
+}
+async function loadCryptoSigning() {
+    if (!hasIndexedDB())
+        return null;
+    return withDb((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(CRYPTO_STORE_NAME, 'readonly');
+        const request = tx.objectStore(CRYPTO_STORE_NAME).get(CRYPTO_RECORD_KEY);
+        request.onsuccess = () => resolve(request.result ?? null);
+        request.onerror = () => reject(request.error);
+    }));
+}
+async function removeCryptoSigning() {
+    if (!hasIndexedDB())
+        return;
+    await withDb((db) => new Promise((resolve, reject) => {
+        const tx = db.transaction(CRYPTO_STORE_NAME, 'readwrite');
+        tx.objectStore(CRYPTO_STORE_NAME).delete(CRYPTO_RECORD_KEY);
+        tx.oncomplete = () => resolve();
+        tx.onerror = () => reject(tx.error);
+    }));
+}
+/**
+ * Persists {@link CryptoSigning} material in the browser's IndexedDB.
+ * The raw bearer token is never stored — only the non-extractable CryptoKey
+ * and the SHA-256 token hash are persisted via the structured clone algorithm.
+ */
+class IndexedDbTokenStore {
+    async save(signing) {
+        await persistCryptoSigning(signing);
+    }
+    async load() {
+        return loadCryptoSigning();
+    }
+    async remove() {
+        await removeCryptoSigning();
+    }
+}
+exports.IndexedDbTokenStore = IndexedDbTokenStore;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/types.d.ts

@@ -1,47 +1,141 @@
-export declare const supportedRequestMethods: readonly ["get", "post", "put", "del", "patch", "options"];
+export declare const supportedRequestMethods: readonly ["get", "post", "put", "del", "patch", "options", "delete"];
 export type AuthVersion = 2 | 3;
-export interface CalculateHmacSubjectOptions {
+export interface CalculateHmacSubjectOptions<T> {
     urlPath: string;
-    text: string;
+    text: T;
     timestamp: number;
     method: (typeof supportedRequestMethods)[number];
     statusCode?: number;
     authVersion: AuthVersion;
 }
-export interface CalculateRequestHmacOptions {
+export interface CalculateRequestHmacOptions<T extends string | Buffer = string> {
     url: string;
-    text: string;
+    text: T;
     timestamp: number;
     token: string;
     method: (typeof supportedRequestMethods)[number];
     authVersion: AuthVersion;
 }
-export interface CalculateRequestHeadersOptions {
+export interface CalculateRequestHeadersOptions<T extends string | Buffer = string> {
     url: string;
-    text: string;
+    text: T;
     token: string;
     method: (typeof supportedRequestMethods)[number];
     authVersion: AuthVersion;
 }
+export type CalculateRequestHeadersWebCryptoOptions<T extends string | Buffer = string> = Omit<CalculateRequestHeadersOptions<T>, 'token'>;
 export interface RequestHeaders {
     hmac: string;
     timestamp: number;
     tokenHash: string;
 }
-export interface VerifyResponseOptions extends CalculateRequestHeadersOptions {
+export interface VerifyResponseOptions<T extends string | Buffer = string> extends CalculateRequestHeadersOptions<T> {
     hmac: string;
     url: string;
-    text: string;
+    text: T;
     timestamp: number;
     method: (typeof supportedRequestMethods)[number];
     statusCode?: number;
     authVersion: AuthVersion;
 }
-export interface VerifyResponseInfo {
+export interface VerifyResponseInfo<T extends string | Buffer = string> {
     isValid: boolean;
     expectedHmac: string;
-    signatureSubject: string;
+    signatureSubject: T;
     isInResponseValidityWindow: boolean;
     verificationTime: number;
 }
+export interface CalculateV4PreimageOptions {
+    timestampSec: number;
+    method: string;
+    pathWithQuery: string;
+    bodyHashHex: string;
+    authRequestId: string;
+}
+export interface CalculateV4RequestHmacOptions extends CalculateV4PreimageOptions {
+    rawToken: string;
+}
+import type { HashableData } from './util';
+export interface CalculateV4RequestHeadersOptions {
+    method: string;
+    pathWithQuery: string;
+    rawBody: HashableData;
+    rawToken: string;
+    authRequestId: string;
+}
+/**
+ * Headers generated for V4 authenticated requests.
+ */
+export interface V4RequestHeaders {
+    hmac: string;
+    timestampSec: number;
+    bodyHashHex: string;
+    authRequestId: string;
+}
+/**
+ * Options for verifying V4 response HMAC.
+ */
+export interface VerifyV4ResponseOptions {
+    hmac: string;
+    timestampSec: number;
+    method: string;
+    pathWithQuery: string;
+    bodyHashHex: string;
+    authRequestId: string;
+    statusCode: number;
+    rawToken: string;
+}
+/**
+ * Result of V4 response HMAC verification.
+ */
+export interface VerifyV4ResponseInfo {
+    isValid: boolean;
+    expectedHmac: string;
+    preimage: string;
+    isInResponseValidityWindow: boolean;
+    verificationTime: number;
+}
+/**
+ * Strategy interface for pluggable HMAC authentication.
+ *
+ * Implementations handle request signing, response verification, and general HMAC
+ * computation. All methods are async to support browser WebCrypto (crypto.subtle).
+ *
+ * The `token` field in params is provided for implementations that use it directly
+ * (e.g. DefaultHmacAuthStrategy). Implementations that manage their own key material
+ * (e.g. WebCryptoHmacStrategy with a CryptoKey) may ignore it.
+ */
+export interface IHmacAuthStrategy {
+    calculateRequestHeaders(params: CalculateRequestHeadersOptions): Promise<RequestHeaders>;
+    verifyResponse(params: VerifyResponseOptions): Promise<VerifyResponseInfo>;
+    calculateHMAC(key: string, message: string): Promise<string>;
+    /**
+     * Optional. Returns true if the strategy has its own signing material
+     * (e.g. a CryptoKey restored from IndexedDB) and can sign requests
+     * independently of BitGoAPI._token.
+     *
+     * When this returns true, BitGoAPI.requestPatch will delegate signing
+     * to the strategy even if no raw token string is available.
+     */
+    isAuthenticated?(): boolean;
+}
+/**
+ * Opaque signing material derived from a bearer token.
+ * Stored in IndexedDB (CryptoKey is preserved via structured clone).
+ * The raw token is never persisted — only the non-extractable key and the hash.
+ */
+export type CryptoSigning = {
+    cryptoKey: CryptoKey;
+    tokenHash: string;
+};
+/**
+ * Pluggable persistence interface for {@link CryptoSigning} material.
+ * Allows different storage backends (IndexedDB, in-memory for tests) for
+ * persisting signing keys across page refreshes or app restarts.
+ */
+export interface ITokenStore {
+    save(signing: CryptoSigning): Promise<void>;
+    load(): Promise<CryptoSigning | null>;
+    remove(): Promise<void>;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/src/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,uBAAuB,4DAA6D,CAAC;AAElG,MAAM,MAAM,WAAW,GAAG,CAAC,GAAG,CAAC,CAAC;AAEhC,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,8BAA8B;IAC7C,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;IACjD,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAsB,SAAQ,8BAA8B;IAC3E,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,CAAC,OAAO,uBAAuB,CAAC,CAAC,MAAM,CAAC,CAAC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,WAAW,CAAC;CAC1B;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,CAAC;IACzB,0BAA0B,EAAE,OAAO,CAAC;IACpC,gBAAgB,EAAE,MAAM,CAAC;CAC1B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":"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"}

package/dist/src/types.js

@@ -1,5 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.supportedRequestMethods = void 0;
-exports.supportedRequestMethods = ['get', 'post', 'put', 'del', 'patch', 'options'];
-//# sourceMappingURL=data:application/json;base64,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
+exports.supportedRequestMethods = ['get', 'post', 'put', 'del', 'patch', 'options', 'delete'];
+//# sourceMappingURL=data:application/json;base64,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