@bitgo-beta/sdk-hmac 1.0.1-beta.97 → 1.0.1-beta.970

package/dist/src/hmac.d.ts

@@ -1,3 +1,4 @@
+import { type BinaryLike, type KeyObject } from 'crypto';
 import { CalculateHmacSubjectOptions, CalculateRequestHeadersOptions, CalculateRequestHmacOptions, RequestHeaders, VerifyResponseInfo, VerifyResponseOptions } from './types';
 /**
  * Calculate the HMAC for the given key and message
@@ -5,7 +6,7 @@ import { CalculateHmacSubjectOptions, CalculateRequestHeadersOptions, CalculateR
  * @param message {String} - the actual message to HMAC
  * @returns {*} - the result of the HMAC operation
  */
-export declare function calculateHMAC(key: string, message: string): string;
+export declare function calculateHMAC(key: string | BinaryLike | KeyObject, message: string | BinaryLike): string;
 /**
  * Calculate the subject string that is to be HMAC'ed for a HTTP request or response
  * @param urlPath request url, including query params
@@ -13,19 +14,21 @@ export declare function calculateHMAC(key: string, message: string): string;
  * @param timestamp request timestamp from `Date.now()`
  * @param statusCode Only set for HTTP responses, leave blank for requests
  * @param method request method
- * @returns {string}
+ * @param authVersion authentication version (2 or 3)
+ * @param useOriginalPath whether to use the original urlPath without parsing (default false)
+ * @returns {string | Buffer}
  */
-export declare function calculateHMACSubject({ urlPath, text, timestamp, statusCode, method, authVersion, }: CalculateHmacSubjectOptions): string;
+export declare function calculateHMACSubject<T extends string | Buffer = string>({ urlPath, text, timestamp, statusCode, method, authVersion }: CalculateHmacSubjectOptions<T>, useOriginalPath?: boolean): T;
 /**
  * Calculate the HMAC for an HTTP request
  */
-export declare function calculateRequestHMAC({ url: urlPath, text, timestamp, token, method, authVersion, }: CalculateRequestHmacOptions): string;
+export declare function calculateRequestHMAC<T extends string | Buffer = string>({ url: urlPath, text, timestamp, token, method, authVersion }: CalculateRequestHmacOptions<T>, useOriginalPath?: boolean): string;
 /**
  * Calculate request headers with HMAC
  */
-export declare function calculateRequestHeaders({ url, text, token, method, authVersion, }: CalculateRequestHeadersOptions): RequestHeaders;
+export declare function calculateRequestHeaders<T extends string | Buffer = string>({ url, text, token, method, authVersion }: CalculateRequestHeadersOptions<T>, useOriginalPath?: boolean): RequestHeaders;
 /**
  * Verify the HMAC for an HTTP response
  */
-export declare function verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac, method, authVersion, }: VerifyResponseOptions): VerifyResponseInfo;
+export declare function verifyResponse<T extends string | Buffer = string>({ url: urlPath, statusCode, text, timestamp, token, hmac, method, authVersion }: VerifyResponseOptions<T>, useOriginalPath?: boolean): VerifyResponseInfo<T>;
 //# sourceMappingURL=hmac.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,2BAA2B,EAC3B,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAEjB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElE;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,MAAM,EACN,WAAW,GACZ,EAAE,2BAA2B,GAAG,MAAM,CAatC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,GAAG,EAAE,OAAO,EACZ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,MAAM,EACN,WAAW,GACZ,EAAE,2BAA2B,GAAG,MAAM,CAKtC;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,EACtC,GAAG,EACH,IAAI,EACJ,KAAK,EACL,MAAM,EACN,WAAW,GACZ,EAAE,8BAA8B,GAAG,cAAc,CAYjD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAC7B,GAAG,EAAE,OAAO,EACZ,UAAU,EACV,IAAI,EACJ,SAAS,EACT,KAAK,EACL,IAAI,EACJ,MAAM,EACN,WAAW,GACZ,EAAE,qBAAqB,GAAG,kBAAkB,CAyB5C"}
+{"version":3,"file":"hmac.d.ts","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,SAAS,EAAE,MAAM,QAAQ,CAAC;AAGzD,OAAO,EACL,2BAA2B,EAC3B,8BAA8B,EAC9B,2BAA2B,EAC3B,cAAc,EACd,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,SAAS,CAAC;AAGjB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,UAAU,GAAG,MAAM,CAExG;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACrE,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,2BAA2B,CAAC,CAAC,CAAC,EAC7F,eAAe,UAAQ,GACtB,CAAC,CA8BH;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACrE,EAAE,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,2BAA2B,CAAC,CAAC,CAAC,EAC7F,eAAe,UAAQ,GACtB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EACxE,EAAE,GAAG,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,8BAA8B,CAAC,CAAC,CAAC,EAC5E,eAAe,UAAQ,GACtB,cAAc,CAYhB;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,EAC/D,EAAE,GAAG,EAAE,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,EAAE,qBAAqB,CAAC,CAAC,CAAC,EACzG,eAAe,UAAQ,GACtB,kBAAkB,CAAC,CAAC,CAAC,CA+BvB"}

package/dist/src/hmac.js

@@ -38,9 +38,9 @@ exports.calculateHMACSubject = calculateHMACSubject;
 exports.calculateRequestHMAC = calculateRequestHMAC;
 exports.calculateRequestHeaders = calculateRequestHeaders;
 exports.verifyResponse = verifyResponse;
-const crypto_1 = require("crypto");
 const urlLib = __importStar(require("url"));
 const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const util_1 = require("./util");
 /**
  * Calculate the HMAC for the given key and message
  * @param key {String} - the key to use for the HMAC
@@ -48,7 +48,7 @@ const sjcl = __importStar(require("@bitgo-beta/sjcl"));
  * @returns {*} - the result of the HMAC operation
  */
 function calculateHMAC(key, message) {
-    return (0, crypto_1.createHmac)('sha256', key).update(message).digest('hex');
+    return (0, util_1.createHmacWithSha256)(key, message);
 }
 /**
  * Calculate the subject string that is to be HMAC'ed for a HTTP request or response
@@ -57,36 +57,53 @@ function calculateHMAC(key, message) {
  * @param timestamp request timestamp from `Date.now()`
  * @param statusCode Only set for HTTP responses, leave blank for requests
  * @param method request method
- * @returns {string}
+ * @param authVersion authentication version (2 or 3)
+ * @param useOriginalPath whether to use the original urlPath without parsing (default false)
+ * @returns {string | Buffer}
  */
-function calculateHMACSubject({ urlPath, text, timestamp, statusCode, method, authVersion, }) {
-    const urlDetails = urlLib.parse(urlPath);
-    const queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;
+function calculateHMACSubject({ urlPath, text, timestamp, statusCode, method, authVersion }, useOriginalPath = false) {
+    /* Normalize legacy 'del' to 'delete' for backward compatibility */
+    if (method === 'del') {
+        method = 'delete';
+    }
+    let queryPath = urlPath;
+    if (!useOriginalPath) {
+        const urlDetails = urlLib.parse(urlPath);
+        queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;
+    }
+    let prefixedText;
     if (statusCode !== undefined && isFinite(statusCode) && Number.isInteger(statusCode)) {
-        if (authVersion === 3) {
-            return [method.toUpperCase(), timestamp, queryPath, statusCode, text].join('|');
-        }
-        return [timestamp, queryPath, statusCode, text].join('|');
+        prefixedText =
+            authVersion === 3
+                ? [method.toUpperCase(), timestamp, queryPath, statusCode].join('|')
+                : [timestamp, queryPath, statusCode].join('|');
+    }
+    else {
+        prefixedText =
+            authVersion === 3
+                ? [method.toUpperCase(), timestamp, '3.0', queryPath].join('|')
+                : [timestamp, queryPath].join('|');
     }
-    if (authVersion === 3) {
-        return [method.toUpperCase(), timestamp, '3.0', queryPath, text].join('|');
+    const isBuffer = Buffer.isBuffer(text);
+    if (isBuffer) {
+        return Buffer.concat([Buffer.from(prefixedText + '|', 'utf-8'), text]);
     }
-    return [timestamp, queryPath, text].join('|');
+    return [prefixedText, text].join('|');
 }
 /**
  * Calculate the HMAC for an HTTP request
  */
-function calculateRequestHMAC({ url: urlPath, text, timestamp, token, method, authVersion, }) {
-    const signatureSubject = calculateHMACSubject({ urlPath, text, timestamp, method, authVersion });
+function calculateRequestHMAC({ url: urlPath, text, timestamp, token, method, authVersion }, useOriginalPath = false) {
+    const signatureSubject = calculateHMACSubject({ urlPath, text, timestamp, method, authVersion }, useOriginalPath);
     // calculate the HMAC
     return calculateHMAC(token, signatureSubject);
 }
 /**
  * Calculate request headers with HMAC
  */
-function calculateRequestHeaders({ url, text, token, method, authVersion, }) {
+function calculateRequestHeaders({ url, text, token, method, authVersion }, useOriginalPath = false) {
     const timestamp = Date.now();
-    const hmac = calculateRequestHMAC({ url, text, timestamp, token, method, authVersion });
+    const hmac = calculateRequestHMAC({ url, text, timestamp, token, method, authVersion }, useOriginalPath);
     // calculate the SHA256 hash of the token
     const hashDigest = sjcl.hash.sha256.hash(token);
     const tokenHash = sjcl.codec.hex.fromBits(hashDigest);
@@ -99,7 +116,7 @@ function calculateRequestHeaders({ url, text, token, method, authVersion, }) {
 /**
  * Verify the HMAC for an HTTP response
  */
-function verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac, method, authVersion, }) {
+function verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac, method, authVersion }, useOriginalPath = false) {
     const signatureSubject = calculateHMACSubject({
         urlPath,
         text,
@@ -107,12 +124,14 @@ function verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac
         statusCode,
         method,
         authVersion,
-    });
+    }, useOriginalPath);
     // calculate the HMAC
     const expectedHmac = calculateHMAC(token, signatureSubject);
-    // determine if the response is still within the validity window (5 minute window)
+    // determine if the response is still within the validity window (5-minute backwards window, 1-minute forward window)
     const now = Date.now();
-    const isInResponseValidityWindow = timestamp >= now - 1000 * 60 * 5 && timestamp <= now;
+    const backwardValidityWindow = 1000 * 60 * 5;
+    const forwardValidityWindow = 1000 * 60;
+    const isInResponseValidityWindow = timestamp >= now - backwardValidityWindow && timestamp <= now + forwardValidityWindow;
     // verify the HMAC and timestamp
     return {
         isValid: expectedHmac === hmac,
@@ -122,4 +141,4 @@ function verifyResponse({ url: urlPath, statusCode, text, timestamp, token, hmac
         verificationTime: now,
     };
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHmac } from 'crypto';\nimport * as urlLib from 'url';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport {\n  CalculateHmacSubjectOptions,\n  CalculateRequestHeadersOptions,\n  CalculateRequestHmacOptions,\n  RequestHeaders,\n  VerifyResponseInfo,\n  VerifyResponseOptions,\n} from './types';\n\n/**\n * Calculate the HMAC for the given key and message\n * @param key {String} - the key to use for the HMAC\n * @param message {String} - the actual message to HMAC\n * @returns {*} - the result of the HMAC operation\n */\nexport function calculateHMAC(key: string, message: string): string {\n  return createHmac('sha256', key).update(message).digest('hex');\n}\n\n/**\n * Calculate the subject string that is to be HMAC'ed for a HTTP request or response\n * @param urlPath request url, including query params\n * @param text request body text\n * @param timestamp request timestamp from `Date.now()`\n * @param statusCode Only set for HTTP responses, leave blank for requests\n * @param method request method\n * @returns {string}\n */\nexport function calculateHMACSubject({\n  urlPath,\n  text,\n  timestamp,\n  statusCode,\n  method,\n  authVersion,\n}: CalculateHmacSubjectOptions): string {\n  const urlDetails = urlLib.parse(urlPath);\n  const queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;\n  if (statusCode !== undefined && isFinite(statusCode) && Number.isInteger(statusCode)) {\n    if (authVersion === 3) {\n      return [method.toUpperCase(), timestamp, queryPath, statusCode, text].join('|');\n    }\n    return [timestamp, queryPath, statusCode, text].join('|');\n  }\n  if (authVersion === 3) {\n    return [method.toUpperCase(), timestamp, '3.0', queryPath, text].join('|');\n  }\n  return [timestamp, queryPath, text].join('|');\n}\n\n/**\n * Calculate the HMAC for an HTTP request\n */\nexport function calculateRequestHMAC({\n  url: urlPath,\n  text,\n  timestamp,\n  token,\n  method,\n  authVersion,\n}: CalculateRequestHmacOptions): string {\n  const signatureSubject = calculateHMACSubject({ urlPath, text, timestamp, method, authVersion });\n\n  // calculate the HMAC\n  return calculateHMAC(token, signatureSubject);\n}\n\n/**\n * Calculate request headers with HMAC\n */\nexport function calculateRequestHeaders({\n  url,\n  text,\n  token,\n  method,\n  authVersion,\n}: CalculateRequestHeadersOptions): RequestHeaders {\n  const timestamp = Date.now();\n  const hmac = calculateRequestHMAC({ url, text, timestamp, token, method, authVersion });\n\n  // calculate the SHA256 hash of the token\n  const hashDigest = sjcl.hash.sha256.hash(token);\n  const tokenHash = sjcl.codec.hex.fromBits(hashDigest);\n  return {\n    hmac,\n    timestamp,\n    tokenHash,\n  };\n}\n\n/**\n * Verify the HMAC for an HTTP response\n */\nexport function verifyResponse({\n  url: urlPath,\n  statusCode,\n  text,\n  timestamp,\n  token,\n  hmac,\n  method,\n  authVersion,\n}: VerifyResponseOptions): VerifyResponseInfo {\n  const signatureSubject = calculateHMACSubject({\n    urlPath,\n    text,\n    timestamp,\n    statusCode,\n    method,\n    authVersion,\n  });\n\n  // calculate the HMAC\n  const expectedHmac = calculateHMAC(token, signatureSubject);\n\n  // determine if the response is still within the validity window (5 minute window)\n  const now = Date.now();\n  const isInResponseValidityWindow = timestamp >= now - 1000 * 60 * 5 && timestamp <= now;\n\n  // verify the HMAC and timestamp\n  return {\n    isValid: expectedHmac === hmac,\n    expectedHmac,\n    signatureSubject,\n    isInResponseValidityWindow,\n    verificationTime: now,\n  };\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hmac.js","sourceRoot":"","sources":["../../src/hmac.ts"],"names":[],"mappings":"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","sourcesContent":["import { type BinaryLike, type KeyObject } from 'crypto';\nimport * as urlLib from 'url';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport {\n  CalculateHmacSubjectOptions,\n  CalculateRequestHeadersOptions,\n  CalculateRequestHmacOptions,\n  RequestHeaders,\n  VerifyResponseInfo,\n  VerifyResponseOptions,\n} from './types';\nimport { createHmacWithSha256 } from './util';\n\n/**\n * Calculate the HMAC for the given key and message\n * @param key {String} - the key to use for the HMAC\n * @param message {String} - the actual message to HMAC\n * @returns {*} - the result of the HMAC operation\n */\nexport function calculateHMAC(key: string | BinaryLike | KeyObject, message: string | BinaryLike): string {\n  return createHmacWithSha256(key, message);\n}\n\n/**\n * Calculate the subject string that is to be HMAC'ed for a HTTP request or response\n * @param urlPath request url, including query params\n * @param text request body text\n * @param timestamp request timestamp from `Date.now()`\n * @param statusCode Only set for HTTP responses, leave blank for requests\n * @param method request method\n * @param authVersion authentication version (2 or 3)\n * @param useOriginalPath whether to use the original urlPath without parsing (default false)\n * @returns {string | Buffer}\n */\nexport function calculateHMACSubject<T extends string | Buffer = string>(\n  { urlPath, text, timestamp, statusCode, method, authVersion }: CalculateHmacSubjectOptions<T>,\n  useOriginalPath = false\n): T {\n  /* Normalize legacy 'del' to 'delete' for backward compatibility */\n  if (method === 'del') {\n    method = 'delete';\n  }\n\n  let queryPath: string | null = urlPath;\n  if (!useOriginalPath) {\n    const urlDetails = urlLib.parse(urlPath);\n    queryPath = urlDetails.query && urlDetails.query.length > 0 ? urlDetails.path : urlDetails.pathname;\n  }\n\n  let prefixedText: string;\n  if (statusCode !== undefined && isFinite(statusCode) && Number.isInteger(statusCode)) {\n    prefixedText =\n      authVersion === 3\n        ? [method.toUpperCase(), timestamp, queryPath, statusCode].join('|')\n        : [timestamp, queryPath, statusCode].join('|');\n  } else {\n    prefixedText =\n      authVersion === 3\n        ? [method.toUpperCase(), timestamp, '3.0', queryPath].join('|')\n        : [timestamp, queryPath].join('|');\n  }\n\n  const isBuffer = Buffer.isBuffer(text);\n  if (isBuffer) {\n    return Buffer.concat([Buffer.from(prefixedText + '|', 'utf-8'), text]) as T;\n  }\n  return [prefixedText, text].join('|') as T;\n}\n\n/**\n * Calculate the HMAC for an HTTP request\n */\nexport function calculateRequestHMAC<T extends string | Buffer = string>(\n  { url: urlPath, text, timestamp, token, method, authVersion }: CalculateRequestHmacOptions<T>,\n  useOriginalPath = false\n): string {\n  const signatureSubject = calculateHMACSubject({ urlPath, text, timestamp, method, authVersion }, useOriginalPath);\n\n  // calculate the HMAC\n  return calculateHMAC(token, signatureSubject);\n}\n\n/**\n * Calculate request headers with HMAC\n */\nexport function calculateRequestHeaders<T extends string | Buffer = string>(\n  { url, text, token, method, authVersion }: CalculateRequestHeadersOptions<T>,\n  useOriginalPath = false\n): RequestHeaders {\n  const timestamp = Date.now();\n  const hmac = calculateRequestHMAC({ url, text, timestamp, token, method, authVersion }, useOriginalPath);\n\n  // calculate the SHA256 hash of the token\n  const hashDigest = sjcl.hash.sha256.hash(token);\n  const tokenHash = sjcl.codec.hex.fromBits(hashDigest);\n  return {\n    hmac,\n    timestamp,\n    tokenHash,\n  };\n}\n\n/**\n * Verify the HMAC for an HTTP response\n */\nexport function verifyResponse<T extends string | Buffer = string>(\n  { url: urlPath, statusCode, text, timestamp, token, hmac, method, authVersion }: VerifyResponseOptions<T>,\n  useOriginalPath = false\n): VerifyResponseInfo<T> {\n  const signatureSubject = calculateHMACSubject(\n    {\n      urlPath,\n      text,\n      timestamp,\n      statusCode,\n      method,\n      authVersion,\n    },\n    useOriginalPath\n  );\n\n  // calculate the HMAC\n  const expectedHmac = calculateHMAC(token, signatureSubject);\n\n  // determine if the response is still within the validity window (5-minute backwards window, 1-minute forward window)\n  const now = Date.now();\n  const backwardValidityWindow = 1000 * 60 * 5;\n  const forwardValidityWindow = 1000 * 60;\n  const isInResponseValidityWindow =\n    timestamp >= now - backwardValidityWindow && timestamp <= now + forwardValidityWindow;\n\n  // verify the HMAC and timestamp\n  return {\n    isValid: expectedHmac === hmac,\n    expectedHmac,\n    signatureSubject,\n    isInResponseValidityWindow,\n    verificationTime: now,\n  };\n}\n"]}

package/dist/src/hmacv4.d.ts

@@ -0,0 +1,185 @@
+/**
+ * @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)
+ */
+import { type HashableData } from './util';
+import { CalculateV4PreimageOptions, CalculateV4RequestHmacOptions, CalculateV4RequestHeadersOptions, V4RequestHeaders, VerifyV4ResponseOptions, VerifyV4ResponseInfo } from './types';
+/**
+ * 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"
+ * ```
+ */
+export declare function calculateV4Preimage({ timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, }: CalculateV4PreimageOptions): string;
+/**
+ * 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)
+ * ```
+ */
+export declare function calculateBodyHash(body: HashableData): string;
+/**
+ * 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',
+ * });
+ * ```
+ */
+export declare function calculateV4RequestHmac({ timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, rawToken, }: CalculateV4RequestHmacOptions): string;
+/**
+ * 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
+ * ```
+ */
+export declare function calculateV4RequestHeaders({ method, pathWithQuery, rawBody, rawToken, authRequestId, }: CalculateV4RequestHeadersOptions): V4RequestHeaders;
+/**
+ * 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
+ */
+export declare function calculateV4ResponsePreimage({ timestampSec, method, pathWithQuery, statusCode, bodyHashHex, authRequestId, }: Omit<VerifyV4ResponseOptions, 'hmac' | 'rawToken'>): string;
+/**
+ * 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
+ */
+export declare function verifyV4Response({ hmac, timestampSec, method, pathWithQuery, bodyHashHex, authRequestId, statusCode, rawToken, }: VerifyV4ResponseOptions): VerifyV4ResponseInfo;
+/**
+ * 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
+ *
+ */
+export declare function getPathWithQuery(xOriginalUri: string | undefined, requestUrl: string): string;
+/**
+ * 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
+ */
+export declare function getMethod(xOriginalMethod: string | undefined, requestMethod: string): string;
+//# sourceMappingURL=hmacv4.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hmacv4.d.ts","sourceRoot":"","sources":["../../src/hmacv4.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,EAML,KAAK,YAAY,EAClB,MAAM,QAAQ,CAAC;AAChB,OAAO,EACL,0BAA0B,EAC1B,6BAA6B,EAC7B,gCAAgC,EAChC,gBAAgB,EAChB,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,SAAS,CAAC;AAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,YAAY,EACZ,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,GACd,EAAE,0BAA0B,GAAG,MAAM,CAOrC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAE5D;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,YAAY,EACZ,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,QAAQ,GACT,EAAE,6BAA6B,GAAG,MAAM,CAUxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,yBAAyB,CAAC,EACxC,MAAM,EACN,aAAa,EACb,OAAO,EACP,QAAQ,EACR,aAAa,GACd,EAAE,gCAAgC,GAAG,gBAAgB,CAmBrD;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,YAAY,EACZ,MAAM,EACN,aAAa,EACb,UAAU,EACV,WAAW,EACX,aAAa,GACd,EAAE,IAAI,CAAC,uBAAuB,EAAE,MAAM,GAAG,UAAU,CAAC,GAAG,MAAM,CAa7D;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gBAAgB,CAAC,EAC/B,IAAI,EACJ,YAAY,EACZ,MAAM,EACN,aAAa,EACb,WAAW,EACX,aAAa,EACb,UAAU,EACV,QAAQ,GACT,EAAE,uBAAuB,GAAG,oBAAoB,CAkChD;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,GAAG,SAAS,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAI7F;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,eAAe,EAAE,MAAM,GAAG,SAAS,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CAG5F"}

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,5 @@
 export * from './hmac';
+export * from './hmacv4';
+export * from './util';
 export * from './types';
 //# 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"}

package/dist/src/index.js

@@ -15,5 +15,7 @@ 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=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHlDQUF1QjtBQUN2QiwyQ0FBeUI7QUFDekIseUNBQXVCO0FBQ3ZCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaG1hYyc7XG5leHBvcnQgKiBmcm9tICcuL2htYWN2NCc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWwnO1xuZXhwb3J0ICogZnJvbSAnLi90eXBlcyc7XG4iXX0=

package/dist/src/types.d.ts

@@ -1,24 +1,24 @@
-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;
@@ -28,19 +28,69 @@ export interface RequestHeaders {
     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;
 }

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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

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/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@bitgo-beta/sdk-hmac",
-  "version": "1.0.1-beta.97",
+  "version": "1.0.1-beta.970",
   "description": "HMAC module for the BitGo SDK",
   "main": "./dist/src/index.js",
   "types": "./dist/src/index.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 +16,7 @@
     "prepare": "npm run build"
   },
   "dependencies": {
-    "@bitgo-beta/sjcl": "1.0.2-beta.969"
+    "@bitgo-beta/sjcl": "1.0.2-beta.1842"
   },
   "devDependencies": {
     "chai": "^4.3.6",
@@ -46,5 +46,5 @@
       ".ts"
     ]
   },
-  "gitHead": "c8b2277e85fcd4da3e31b82ea8e3c0ac1e98ed80"
+  "gitHead": "025735cf19973e1aeb7e13be2aea92a9a2f32657"
 }