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

package/dist/src/util.d.ts

@@ -0,0 +1,49 @@
+import { type BinaryLike, type KeyObject } from 'crypto';
+export type HashableData = string | Buffer | Uint8Array | ArrayBuffer;
+/**
+ * Calculate SHA256 hash of data and return as lowercase hex string.
+ * Used for body hash calculation in v4 authentication.
+ *
+ * Accepts string, Buffer, Uint8Array, and ArrayBuffer for compatibility
+ * with both Node.js and browser environments.
+ *
+ * Note: ArrayBuffer is converted to Uint8Array internally since Node.js crypto
+ * requires TypedArray or DataView, not plain ArrayBuffer.
+ *
+ * @param data - The data to hash
+ * @returns Lowercase hex string of SHA256 hash
+ */
+export declare function sha256Hex(data: HashableData): string;
+/**
+ * Calculate HMAC-SHA256 and return as lowercase hex string.
+ * This is the core cryptographic primitive shared by v2/v3/v4 authentication.
+ *
+ * @param key - The secret key for HMAC
+ * @param message - The message to authenticate
+ * @returns Lowercase hex string of HMAC-SHA256
+ */
+export declare function createHmacWithSha256(key: string | BinaryLike | KeyObject, message: string | BinaryLike): string;
+/**
+ * Normalize HTTP method to uppercase.
+ * Handles legacy 'del' → 'DELETE' conversion for backward compatibility.
+ *
+ * @param method - HTTP method (case-insensitive)
+ * @returns Uppercase HTTP method
+ */
+export declare function normalizeMethod(method: string): string;
+/**
+ * Extract path with query string from a URL.
+ * Handles both absolute URLs and relative paths.
+ *
+ * @param urlPath - Full URL or relative path
+ * @returns Path with query string (e.g., '/api/v2/wallet?foo=bar')
+ */
+export declare function extractPathWithQuery(urlPath: string): string;
+/**
+ * Get current timestamp in seconds (Unix epoch).
+ * Used for v4 authentication which uses seconds instead of milliseconds.
+ *
+ * @returns Current Unix timestamp in seconds
+ */
+export declare function getTimestampSec(): number;
+//# sourceMappingURL=util.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../src/util.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAC;AAEjF,MAAM,MAAM,YAAY,GAAG,MAAM,GAAG,MAAM,GAAG,UAAU,GAAG,WAAW,CAAC;AAEtE;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAKpD;AAED;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAE/G;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAMtD;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAa5D;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,IAAI,MAAM,CAExC"}

package/dist/src/util.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sha256Hex = sha256Hex;
+exports.createHmacWithSha256 = createHmacWithSha256;
+exports.normalizeMethod = normalizeMethod;
+exports.extractPathWithQuery = extractPathWithQuery;
+exports.getTimestampSec = getTimestampSec;
+const crypto_1 = require("crypto");
+/**
+ * Calculate SHA256 hash of data and return as lowercase hex string.
+ * Used for body hash calculation in v4 authentication.
+ *
+ * Accepts string, Buffer, Uint8Array, and ArrayBuffer for compatibility
+ * with both Node.js and browser environments.
+ *
+ * Note: ArrayBuffer is converted to Uint8Array internally since Node.js crypto
+ * requires TypedArray or DataView, not plain ArrayBuffer.
+ *
+ * @param data - The data to hash
+ * @returns Lowercase hex string of SHA256 hash
+ */
+function sha256Hex(data) {
+    const normalizedData = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+    return (0, crypto_1.createHash)('sha256')
+        .update(normalizedData)
+        .digest('hex');
+}
+/**
+ * Calculate HMAC-SHA256 and return as lowercase hex string.
+ * This is the core cryptographic primitive shared by v2/v3/v4 authentication.
+ *
+ * @param key - The secret key for HMAC
+ * @param message - The message to authenticate
+ * @returns Lowercase hex string of HMAC-SHA256
+ */
+function createHmacWithSha256(key, message) {
+    return (0, crypto_1.createHmac)('sha256', key).update(message).digest('hex');
+}
+/**
+ * Normalize HTTP method to uppercase.
+ * Handles legacy 'del' → 'DELETE' conversion for backward compatibility.
+ *
+ * @param method - HTTP method (case-insensitive)
+ * @returns Uppercase HTTP method
+ */
+function normalizeMethod(method) {
+    const lowerMethod = method.toLowerCase();
+    if (lowerMethod === 'del') {
+        return 'DELETE';
+    }
+    return method.toUpperCase();
+}
+/**
+ * Extract path with query string from a URL.
+ * Handles both absolute URLs and relative paths.
+ *
+ * @param urlPath - Full URL or relative path
+ * @returns Path with query string (e.g., '/api/v2/wallet?foo=bar')
+ */
+function extractPathWithQuery(urlPath) {
+    try {
+        // Try parsing as absolute URL first
+        const url = new URL(urlPath);
+        return url.pathname + url.search;
+    }
+    catch {
+        try {
+            const url = new URL(urlPath, 'http://localhost');
+            return url.pathname + url.search;
+        }
+        catch {
+            return urlPath;
+        }
+    }
+}
+/**
+ * Get current timestamp in seconds (Unix epoch).
+ * Used for v4 authentication which uses seconds instead of milliseconds.
+ *
+ * @returns Current Unix timestamp in seconds
+ */
+function getTimestampSec() {
+    return Math.floor(Date.now() / 1000);
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/src/webCryptoStrategy.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Browser-native HMAC auth strategy using the Web Crypto API.
+ *
+ * All browser API usage (crypto.subtle) is inside method bodies,
+ * so the module can be safely imported in any environment -- it only requires
+ * browser globals when methods are actually called.
+ */
+import type { AuthVersion, IHmacAuthStrategy, ITokenStore, CalculateRequestHeadersWebCryptoOptions, RequestHeaders, VerifyResponseOptions, VerifyResponseInfo } from './types';
+export interface WebCryptoHmacStrategyOptions {
+    tokenStore?: ITokenStore;
+    authVersion?: AuthVersion;
+}
+/**
+ * HMAC auth strategy using the browser's Web Crypto API (crypto.subtle).
+ *
+ * Usable both as an `IHmacAuthStrategy` for BitGoAPI and as a standalone
+ * utility for signing/verifying requests made with the browser `fetch()` API.
+ *
+ * Token lifecycle:
+ *  - Call `setToken(rawToken)` after authentication to import the token as a
+ *    non-extractable CryptoKey and persist it to the configured ITokenStore.
+ *  - Call `restoreToken()` on page load to recover a previously stored token.
+ *  - Call `clearToken()` on logout.
+ */
+export declare class WebCryptoHmacStrategy implements IHmacAuthStrategy {
+    private cryptoKey;
+    private tokenHashHex;
+    private tokenStore;
+    private authVersion;
+    constructor(options?: WebCryptoHmacStrategyOptions);
+    /**
+     * Import a raw bearer token: derives a non-extractable CryptoKey for HMAC
+     * signing, computes the SHA-256 token hash, and persists the
+     * {@link CryptoSigning} material (NOT the raw token) to the token store.
+     */
+    setToken(rawToken: string): Promise<void>;
+    clearToken(): Promise<void>;
+    /**
+     * Attempt to restore signing material from the token store (e.g. IndexedDB).
+     * The stored {@link CryptoSigning} already contains the non-extractable
+     * CryptoKey and token hash — no raw token is involved.
+     * Returns true if signing material was successfully restored.
+     */
+    restoreToken(): Promise<boolean>;
+    hasToken(): boolean;
+    isAuthenticated(): boolean;
+    calculateRequestHeaders(params: CalculateRequestHeadersWebCryptoOptions): Promise<RequestHeaders>;
+    verifyResponse(params: VerifyResponseOptions): Promise<VerifyResponseInfo>;
+    calculateHMAC(key: string, message: string): Promise<string>;
+    /**
+     * Returns a flat headers dict ready to spread into a `fetch()` init object.
+     *
+     * Example:
+     * ```
+     * const headers = await strategy.getAuthHeaders({ url, method: 'GET' });
+     * const response = await fetch(url, { headers });
+     * ```
+     */
+    getAuthHeaders(params: {
+        url: string;
+        method: string;
+        body?: string;
+    }): Promise<Record<string, string>>;
+    /**
+     * Verify a browser Fetch `Response` object's HMAC.
+     *
+     * Clones the response to read the body text without consuming it.
+     */
+    verifyFetchResponse(params: {
+        url: string;
+        method: string;
+        response: Response;
+    }): Promise<VerifyResponseInfo>;
+}
+//# sourceMappingURL=webCryptoStrategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"webCryptoStrategy.d.ts","sourceRoot":"","sources":["../../src/webCryptoStrategy.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EACV,WAAW,EACX,iBAAiB,EACjB,WAAW,EACX,uCAAuC,EACvC,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAiDjB,MAAM,WAAW,4BAA4B;IAC3C,UAAU,CAAC,EAAE,WAAW,CAAC;IACzB,WAAW,CAAC,EAAE,WAAW,CAAC;CAC3B;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,qBAAsB,YAAW,iBAAiB;IAC7D,OAAO,CAAC,SAAS,CAA0B;IAC3C,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,UAAU,CAAc;IAChC,OAAO,CAAC,WAAW,CAAc;gBAErB,OAAO,CAAC,EAAE,4BAA4B;IAOlD;;;;OAIG;IACG,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAMzC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAMjC;;;;;OAKG;IACG,YAAY,IAAI,OAAO,CAAC,OAAO,CAAC;IAUtC,QAAQ,IAAI,OAAO;IAInB,eAAe,IAAI,OAAO;IAMpB,uBAAuB,CAAC,MAAM,EAAE,uCAAuC,GAAG,OAAO,CAAC,cAAc,CAAC;IAgBjG,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8B1E,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAOlE;;;;;;;;OAQG;IACG,cAAc,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAe7G;;;;OAIG;IACG,mBAAmB,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAA;KAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAcpH"}

package/dist/src/webCryptoStrategy.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebCryptoHmacStrategy = void 0;
+const hmac_1 = require("./hmac");
+const indexedDbTokenStore_1 = require("./indexedDbTokenStore");
+function arrayBufToHex(buffer) {
+    const bytes = new Uint8Array(buffer);
+    const hexParts = new Array(bytes.length);
+    for (let i = 0; i < bytes.length; i++) {
+        hexParts[i] = bytes[i].toString(16).padStart(2, '0');
+    }
+    return hexParts.join('');
+}
+async function webCryptoHmacSign(key, data) {
+    const encoded = new TextEncoder().encode(data);
+    const sig = await crypto.subtle.sign('HMAC', key, encoded);
+    return arrayBufToHex(sig);
+}
+async function webCryptoImportHmacKey(rawKey) {
+    const encoded = new TextEncoder().encode(rawKey);
+    return crypto.subtle.importKey('raw', encoded, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
+}
+/**
+ * Constant-time string comparison to prevent timing side-channel attacks.
+ * Browser-compatible polyfill for Node's `crypto.timingSafeEqual`.
+ */
+function timingSafeStringEqual(a, b) {
+    const aBytes = new TextEncoder().encode(a);
+    const bBytes = new TextEncoder().encode(b);
+    if (aBytes.length !== bBytes.length)
+        return false;
+    let result = 0;
+    for (let i = 0; i < aBytes.length; i++) {
+        result |= aBytes[i] ^ bBytes[i];
+    }
+    return result === 0;
+}
+async function webCryptoSha256Hex(data) {
+    const encoded = new TextEncoder().encode(data);
+    const hash = await crypto.subtle.digest('SHA-256', encoded);
+    return arrayBufToHex(hash);
+}
+/**
+ * HMAC auth strategy using the browser's Web Crypto API (crypto.subtle).
+ *
+ * Usable both as an `IHmacAuthStrategy` for BitGoAPI and as a standalone
+ * utility for signing/verifying requests made with the browser `fetch()` API.
+ *
+ * Token lifecycle:
+ *  - Call `setToken(rawToken)` after authentication to import the token as a
+ *    non-extractable CryptoKey and persist it to the configured ITokenStore.
+ *  - Call `restoreToken()` on page load to recover a previously stored token.
+ *  - Call `clearToken()` on logout.
+ */
+class WebCryptoHmacStrategy {
+    constructor(options) {
+        this.cryptoKey = null;
+        this.tokenHashHex = null;
+        this.tokenStore = options?.tokenStore ?? new indexedDbTokenStore_1.IndexedDbTokenStore();
+        this.authVersion = options?.authVersion ?? 2;
+    }
+    // --- Token lifecycle ---------------------------------------------------
+    /**
+     * Import a raw bearer token: derives a non-extractable CryptoKey for HMAC
+     * signing, computes the SHA-256 token hash, and persists the
+     * {@link CryptoSigning} material (NOT the raw token) to the token store.
+     */
+    async setToken(rawToken) {
+        this.cryptoKey = await webCryptoImportHmacKey(rawToken);
+        this.tokenHashHex = await webCryptoSha256Hex(rawToken);
+        await this.tokenStore.save({ cryptoKey: this.cryptoKey, tokenHash: this.tokenHashHex });
+    }
+    async clearToken() {
+        this.cryptoKey = null;
+        this.tokenHashHex = null;
+        await this.tokenStore.remove();
+    }
+    /**
+     * Attempt to restore signing material from the token store (e.g. IndexedDB).
+     * The stored {@link CryptoSigning} already contains the non-extractable
+     * CryptoKey and token hash — no raw token is involved.
+     * Returns true if signing material was successfully restored.
+     */
+    async restoreToken() {
+        const signing = await this.tokenStore.load();
+        if (signing) {
+            this.cryptoKey = signing.cryptoKey;
+            this.tokenHashHex = signing.tokenHash;
+            return true;
+        }
+        return false;
+    }
+    hasToken() {
+        return this.cryptoKey !== null && this.tokenHashHex !== null;
+    }
+    isAuthenticated() {
+        return this.hasToken();
+    }
+    // --- IHmacAuthStrategy implementation -----------------------------------
+    async calculateRequestHeaders(params) {
+        if (!this.cryptoKey || !this.tokenHashHex) {
+            throw new Error('No token available. Call setToken() or restoreToken() first.');
+        }
+        const timestamp = Date.now();
+        const subject = (0, hmac_1.calculateHMACSubject)({
+            urlPath: params.url,
+            text: params.text,
+            timestamp,
+            method: params.method,
+            authVersion: params.authVersion,
+        });
+        const hmac = await webCryptoHmacSign(this.cryptoKey, subject);
+        return { hmac, timestamp, tokenHash: this.tokenHashHex };
+    }
+    async verifyResponse(params) {
+        if (!this.cryptoKey) {
+            throw new Error('No token available. Call setToken() or restoreToken() first.');
+        }
+        const subject = (0, hmac_1.calculateHMACSubject)({
+            urlPath: params.url,
+            text: params.text,
+            timestamp: params.timestamp,
+            method: params.method,
+            statusCode: params.statusCode,
+            authVersion: params.authVersion,
+        });
+        const expectedHmac = await webCryptoHmacSign(this.cryptoKey, subject);
+        const now = Date.now();
+        const backwardValidityWindow = 1000 * 60 * 5;
+        const forwardValidityWindow = 1000 * 60;
+        const isInResponseValidityWindow = params.timestamp >= now - backwardValidityWindow && params.timestamp <= now + forwardValidityWindow;
+        return {
+            isValid: timingSafeStringEqual(expectedHmac, params.hmac),
+            expectedHmac,
+            signatureSubject: subject,
+            isInResponseValidityWindow,
+            verificationTime: now,
+        };
+    }
+    async calculateHMAC(key, message) {
+        const cryptoKey = await webCryptoImportHmacKey(key);
+        return webCryptoHmacSign(cryptoKey, message);
+    }
+    // --- Convenience methods for standalone fetch() usage -------------------
+    /**
+     * Returns a flat headers dict ready to spread into a `fetch()` init object.
+     *
+     * Example:
+     * ```
+     * const headers = await strategy.getAuthHeaders({ url, method: 'GET' });
+     * const response = await fetch(url, { headers });
+     * ```
+     */
+    async getAuthHeaders(params) {
+        const requestHeaders = await this.calculateRequestHeaders({
+            url: params.url,
+            method: params.method,
+            text: params.body ?? '',
+            authVersion: this.authVersion,
+        });
+        return {
+            'Auth-Timestamp': requestHeaders.timestamp.toString(),
+            Authorization: 'Bearer ' + requestHeaders.tokenHash,
+            HMAC: requestHeaders.hmac,
+            'BitGo-Auth-Version': this.authVersion === 3 ? '3.0' : '2.0',
+        };
+    }
+    /**
+     * Verify a browser Fetch `Response` object's HMAC.
+     *
+     * Clones the response to read the body text without consuming it.
+     */
+    async verifyFetchResponse(params) {
+        const cloned = params.response.clone();
+        const text = await cloned.text();
+        return this.verifyResponse({
+            url: params.url,
+            token: '',
+            method: params.method,
+            text,
+            hmac: params.response.headers.get('hmac') ?? '',
+            statusCode: params.response.status,
+            timestamp: parseInt(params.response.headers.get('timestamp') ?? '0', 10),
+            authVersion: this.authVersion,
+        });
+    }
+}
+exports.WebCryptoHmacStrategy = WebCryptoHmacStrategy;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"webCryptoStrategy.js","sourceRoot":"","sources":["../../src/webCryptoStrategy.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Browser-native HMAC auth strategy using the Web Crypto API.\n *\n * All browser API usage (crypto.subtle) is inside method bodies,\n * so the module can be safely imported in any environment -- it only requires\n * browser globals when methods are actually called.\n */\nimport type {\n  AuthVersion,\n  IHmacAuthStrategy,\n  ITokenStore,\n  CalculateRequestHeadersWebCryptoOptions,\n  RequestHeaders,\n  VerifyResponseOptions,\n  VerifyResponseInfo,\n} from './types';\nimport { calculateHMACSubject } from './hmac';\nimport { IndexedDbTokenStore } from './indexedDbTokenStore';\n\nfunction arrayBufToHex(buffer: ArrayBuffer): string {\n  const bytes = new Uint8Array(buffer);\n  const hexParts: string[] = new Array(bytes.length);\n  for (let i = 0; i < bytes.length; i++) {\n    hexParts[i] = bytes[i].toString(16).padStart(2, '0');\n  }\n  return hexParts.join('');\n}\n\nasync function webCryptoHmacSign(key: CryptoKey, data: string): Promise<string> {\n  const encoded = new TextEncoder().encode(data);\n  const sig = await crypto.subtle.sign('HMAC', key, encoded);\n  return arrayBufToHex(sig);\n}\n\nasync function webCryptoImportHmacKey(rawKey: string): Promise<CryptoKey> {\n  const encoded = new TextEncoder().encode(rawKey);\n  return crypto.subtle.importKey('raw', encoded, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);\n}\n\n/**\n * Constant-time string comparison to prevent timing side-channel attacks.\n * Browser-compatible polyfill for Node's `crypto.timingSafeEqual`.\n */\nfunction timingSafeStringEqual(a: string, b: string): boolean {\n  const aBytes = new TextEncoder().encode(a);\n  const bBytes = new TextEncoder().encode(b);\n  if (aBytes.length !== bBytes.length) return false;\n  let result = 0;\n  for (let i = 0; i < aBytes.length; i++) {\n    result |= aBytes[i] ^ bBytes[i];\n  }\n  return result === 0;\n}\n\nasync function webCryptoSha256Hex(data: string): Promise<string> {\n  const encoded = new TextEncoder().encode(data);\n  const hash = await crypto.subtle.digest('SHA-256', encoded);\n  return arrayBufToHex(hash);\n}\n\n// ---------------------------------------------------------------------------\n// WebCrypto HMAC Strategy\n// ---------------------------------------------------------------------------\n\nexport interface WebCryptoHmacStrategyOptions {\n  tokenStore?: ITokenStore;\n  authVersion?: AuthVersion;\n}\n\n/**\n * HMAC auth strategy using the browser's Web Crypto API (crypto.subtle).\n *\n * Usable both as an `IHmacAuthStrategy` for BitGoAPI and as a standalone\n * utility for signing/verifying requests made with the browser `fetch()` API.\n *\n * Token lifecycle:\n *  - Call `setToken(rawToken)` after authentication to import the token as a\n *    non-extractable CryptoKey and persist it to the configured ITokenStore.\n *  - Call `restoreToken()` on page load to recover a previously stored token.\n *  - Call `clearToken()` on logout.\n */\nexport class WebCryptoHmacStrategy implements IHmacAuthStrategy {\n  private cryptoKey: CryptoKey | null = null;\n  private tokenHashHex: string | null = null;\n  private tokenStore: ITokenStore;\n  private authVersion: AuthVersion;\n\n  constructor(options?: WebCryptoHmacStrategyOptions) {\n    this.tokenStore = options?.tokenStore ?? new IndexedDbTokenStore();\n    this.authVersion = options?.authVersion ?? 2;\n  }\n\n  // --- Token lifecycle ---------------------------------------------------\n\n  /**\n   * Import a raw bearer token: derives a non-extractable CryptoKey for HMAC\n   * signing, computes the SHA-256 token hash, and persists the\n   * {@link CryptoSigning} material (NOT the raw token) to the token store.\n   */\n  async setToken(rawToken: string): Promise<void> {\n    this.cryptoKey = await webCryptoImportHmacKey(rawToken);\n    this.tokenHashHex = await webCryptoSha256Hex(rawToken);\n    await this.tokenStore.save({ cryptoKey: this.cryptoKey, tokenHash: this.tokenHashHex });\n  }\n\n  async clearToken(): Promise<void> {\n    this.cryptoKey = null;\n    this.tokenHashHex = null;\n    await this.tokenStore.remove();\n  }\n\n  /**\n   * Attempt to restore signing material from the token store (e.g. IndexedDB).\n   * The stored {@link CryptoSigning} already contains the non-extractable\n   * CryptoKey and token hash — no raw token is involved.\n   * Returns true if signing material was successfully restored.\n   */\n  async restoreToken(): Promise<boolean> {\n    const signing = await this.tokenStore.load();\n    if (signing) {\n      this.cryptoKey = signing.cryptoKey;\n      this.tokenHashHex = signing.tokenHash;\n      return true;\n    }\n    return false;\n  }\n\n  hasToken(): boolean {\n    return this.cryptoKey !== null && this.tokenHashHex !== null;\n  }\n\n  isAuthenticated(): boolean {\n    return this.hasToken();\n  }\n\n  // --- IHmacAuthStrategy implementation -----------------------------------\n\n  async calculateRequestHeaders(params: CalculateRequestHeadersWebCryptoOptions): Promise<RequestHeaders> {\n    if (!this.cryptoKey || !this.tokenHashHex) {\n      throw new Error('No token available. Call setToken() or restoreToken() first.');\n    }\n    const timestamp = Date.now();\n    const subject = calculateHMACSubject({\n      urlPath: params.url,\n      text: params.text,\n      timestamp,\n      method: params.method,\n      authVersion: params.authVersion,\n    });\n    const hmac = await webCryptoHmacSign(this.cryptoKey, subject);\n    return { hmac, timestamp, tokenHash: this.tokenHashHex };\n  }\n\n  async verifyResponse(params: VerifyResponseOptions): Promise<VerifyResponseInfo> {\n    if (!this.cryptoKey) {\n      throw new Error('No token available. Call setToken() or restoreToken() first.');\n    }\n    const subject = calculateHMACSubject({\n      urlPath: params.url,\n      text: params.text,\n      timestamp: params.timestamp,\n      method: params.method,\n      statusCode: params.statusCode,\n      authVersion: params.authVersion,\n    });\n\n    const expectedHmac = await webCryptoHmacSign(this.cryptoKey, subject);\n\n    const now = Date.now();\n    const backwardValidityWindow = 1000 * 60 * 5;\n    const forwardValidityWindow = 1000 * 60;\n    const isInResponseValidityWindow =\n      params.timestamp >= now - backwardValidityWindow && params.timestamp <= now + forwardValidityWindow;\n\n    return {\n      isValid: timingSafeStringEqual(expectedHmac, params.hmac),\n      expectedHmac,\n      signatureSubject: subject as VerifyResponseInfo['signatureSubject'],\n      isInResponseValidityWindow,\n      verificationTime: now,\n    };\n  }\n\n  async calculateHMAC(key: string, message: string): Promise<string> {\n    const cryptoKey = await webCryptoImportHmacKey(key);\n    return webCryptoHmacSign(cryptoKey, message);\n  }\n\n  // --- Convenience methods for standalone fetch() usage -------------------\n\n  /**\n   * Returns a flat headers dict ready to spread into a `fetch()` init object.\n   *\n   * Example:\n   * ```\n   * const headers = await strategy.getAuthHeaders({ url, method: 'GET' });\n   * const response = await fetch(url, { headers });\n   * ```\n   */\n  async getAuthHeaders(params: { url: string; method: string; body?: string }): Promise<Record<string, string>> {\n    const requestHeaders = await this.calculateRequestHeaders({\n      url: params.url,\n      method: params.method as CalculateRequestHeadersWebCryptoOptions['method'],\n      text: params.body ?? '',\n      authVersion: this.authVersion,\n    });\n    return {\n      'Auth-Timestamp': requestHeaders.timestamp.toString(),\n      Authorization: 'Bearer ' + requestHeaders.tokenHash,\n      HMAC: requestHeaders.hmac,\n      'BitGo-Auth-Version': this.authVersion === 3 ? '3.0' : '2.0',\n    };\n  }\n\n  /**\n   * Verify a browser Fetch `Response` object's HMAC.\n   *\n   * Clones the response to read the body text without consuming it.\n   */\n  async verifyFetchResponse(params: { url: string; method: string; response: Response }): Promise<VerifyResponseInfo> {\n    const cloned = params.response.clone();\n    const text = await cloned.text();\n    return this.verifyResponse({\n      url: params.url,\n      token: '',\n      method: params.method as VerifyResponseOptions['method'],\n      text,\n      hmac: params.response.headers.get('hmac') ?? '',\n      statusCode: params.response.status,\n      timestamp: parseInt(params.response.headers.get('timestamp') ?? '0', 10),\n      authVersion: this.authVersion,\n    });\n  }\n}\n"]}

package/package.json

@@ -1,13 +1,30 @@
 {
   "name": "@bitgo-beta/sdk-hmac",
-  "version": "1.0.1-beta.102",
+  "version": "1.0.1-beta.1021",
   "description": "HMAC module for the BitGo SDK",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/src/index.js"
+    },
+    "./browser": {
+      "types": "./dist/src/browser.d.ts",
+      "default": "./dist/src/browser.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "browser": [
+        "./dist/src/browser.d.ts"
+      ]
+    }
+  },
   "scripts": {
     "build": "yarn tsc --build --incremental --verbose .",
     "fmt": "prettier --write .",
-    "check-fmt": "prettier --check .",
+    "check-fmt": "prettier --check '**/*.{ts,js,json}'",
     "clean": "rm -r ./dist",
     "lint": "eslint --quiet .",
     "test": "npm run coverage",
@@ -16,7 +33,7 @@
     "prepare": "npm run build"
   },
   "dependencies": {
-    "@bitgo-beta/sjcl": "1.0.2-beta.974"
+    "@bitgo-beta/sjcl": "1.0.2-beta.1893"
   },
   "devDependencies": {
     "chai": "^4.3.6",
@@ -46,5 +63,5 @@
       ".ts"
     ]
   },
-  "gitHead": "a8223d20b478c43d0486e270ce6b84b2eb15a944"
+  "gitHead": "be29a647eac8a4aba15ab8e4fd5ceeb6d438630c"
 }