@bitgo-beta/sdk-hmac 1.0.1-beta.13 → 1.0.1-beta.1300

package/dist/src/browser.d.ts

@@ -0,0 +1,4 @@
+export * from './index';
+export * from './indexedDbTokenStore';
+export * from './webCryptoStrategy';
+//# sourceMappingURL=browser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/browser.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC"}

package/dist/src/browser.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./index"), exports);
+__exportStar(require("./indexedDbTokenStore"), exports);
+__exportStar(require("./webCryptoStrategy"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnJvd3Nlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9icm93c2VyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsd0RBQXNDO0FBQ3RDLHNEQUFvQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vaW5kZXgnO1xuZXhwb3J0ICogZnJvbSAnLi9pbmRleGVkRGJUb2tlblN0b3JlJztcbmV4cG9ydCAqIGZyb20gJy4vd2ViQ3J5cHRvU3RyYXRlZ3knO1xuIl19

package/dist/src/defaultStrategy.d.ts

@@ -0,0 +1,11 @@
+import type { IHmacAuthStrategy, CalculateRequestHeadersOptions, RequestHeaders, VerifyResponseOptions, VerifyResponseInfo } from './types';
+/**
+ * Default HMAC auth strategy that wraps the existing synchronous Node.js crypto
+ * functions. This is used when no custom strategy is provided to BitGoAPI.
+ */
+export declare class DefaultHmacAuthStrategy implements IHmacAuthStrategy {
+    calculateRequestHeaders(params: CalculateRequestHeadersOptions): Promise<RequestHeaders>;
+    verifyResponse(params: VerifyResponseOptions): Promise<VerifyResponseInfo>;
+    calculateHMAC(key: string, message: string): Promise<string>;
+}
+//# sourceMappingURL=defaultStrategy.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"defaultStrategy.d.ts","sourceRoot":"","sources":["../../src/defaultStrategy.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,iBAAiB,EACjB,8BAA8B,EAC9B,cAAc,EACd,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,SAAS,CAAC;AAEjB;;;GAGG;AACH,qBAAa,uBAAwB,YAAW,iBAAiB;IACzD,uBAAuB,CAAC,MAAM,EAAE,8BAA8B,GAAG,OAAO,CAAC,cAAc,CAAC;IAIxF,cAAc,CAAC,MAAM,EAAE,qBAAqB,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAI1E,aAAa,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAGnE"}

package/dist/src/defaultStrategy.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultHmacAuthStrategy = void 0;
+const hmac_1 = require("./hmac");
+/**
+ * Default HMAC auth strategy that wraps the existing synchronous Node.js crypto
+ * functions. This is used when no custom strategy is provided to BitGoAPI.
+ */
+class DefaultHmacAuthStrategy {
+    async calculateRequestHeaders(params) {
+        return (0, hmac_1.calculateRequestHeaders)(params);
+    }
+    async verifyResponse(params) {
+        return (0, hmac_1.verifyResponse)(params);
+    }
+    async calculateHMAC(key, message) {
+        return (0, hmac_1.calculateHMAC)(key, message);
+    }
+}
+exports.DefaultHmacAuthStrategy = DefaultHmacAuthStrategy;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVmYXVsdFN0cmF0ZWd5LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2RlZmF1bHRTdHJhdGVneS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxpQ0FBZ0Y7QUFTaEY7OztHQUdHO0FBQ0gsTUFBYSx1QkFBdUI7SUFDbEMsS0FBSyxDQUFDLHVCQUF1QixDQUFDLE1BQXNDO1FBQ2xFLE9BQU8sSUFBQSw4QkFBdUIsRUFBQyxNQUFNLENBQUMsQ0FBQztJQUN6QyxDQUFDO0lBRUQsS0FBSyxDQUFDLGNBQWMsQ0FBQyxNQUE2QjtRQUNoRCxPQUFPLElBQUEscUJBQWMsRUFBQyxNQUFNLENBQUMsQ0FBQztJQUNoQyxDQUFDO0lBRUQsS0FBSyxDQUFDLGFBQWEsQ0FBQyxHQUFXLEVBQUUsT0FBZTtRQUM5QyxPQUFPLElBQUEsb0JBQWEsRUFBQyxHQUFHLEVBQUUsT0FBTyxDQUFDLENBQUM7SUFDckMsQ0FBQztDQUNGO0FBWkQsMERBWUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBjYWxjdWxhdGVSZXF1ZXN0SGVhZGVycywgY2FsY3VsYXRlSE1BQywgdmVyaWZ5UmVzcG9uc2UgfSBmcm9tICcuL2htYWMnO1xuaW1wb3J0IHR5cGUge1xuICBJSG1hY0F1dGhTdHJhdGVneSxcbiAgQ2FsY3VsYXRlUmVxdWVzdEhlYWRlcnNPcHRpb25zLFxuICBSZXF1ZXN0SGVhZGVycyxcbiAgVmVyaWZ5UmVzcG9uc2VPcHRpb25zLFxuICBWZXJpZnlSZXNwb25zZUluZm8sXG59IGZyb20gJy4vdHlwZXMnO1xuXG4vKipcbiAqIERlZmF1bHQgSE1BQyBhdXRoIHN0cmF0ZWd5IHRoYXQgd3JhcHMgdGhlIGV4aXN0aW5nIHN5bmNocm9ub3VzIE5vZGUuanMgY3J5cHRvXG4gKiBmdW5jdGlvbnMuIFRoaXMgaXMgdXNlZCB3aGVuIG5vIGN1c3RvbSBzdHJhdGVneSBpcyBwcm92aWRlZCB0byBCaXRHb0FQSS5cbiAqL1xuZXhwb3J0IGNsYXNzIERlZmF1bHRIbWFjQXV0aFN0cmF0ZWd5IGltcGxlbWVudHMgSUhtYWNBdXRoU3RyYXRlZ3kge1xuICBhc3luYyBjYWxjdWxhdGVSZXF1ZXN0SGVhZGVycyhwYXJhbXM6IENhbGN1bGF0ZVJlcXVlc3RIZWFkZXJzT3B0aW9ucyk6IFByb21pc2U8UmVxdWVzdEhlYWRlcnM+IHtcbiAgICByZXR1cm4gY2FsY3VsYXRlUmVxdWVzdEhlYWRlcnMocGFyYW1zKTtcbiAgfVxuXG4gIGFzeW5jIHZlcmlmeVJlc3BvbnNlKHBhcmFtczogVmVyaWZ5UmVzcG9uc2VPcHRpb25zKTogUHJvbWlzZTxWZXJpZnlSZXNwb25zZUluZm8+IHtcbiAgICByZXR1cm4gdmVyaWZ5UmVzcG9uc2UocGFyYW1zKTtcbiAgfVxuXG4gIGFzeW5jIGNhbGN1bGF0ZUhNQUMoa2V5OiBzdHJpbmcsIG1lc3NhZ2U6IHN0cmluZyk6IFByb21pc2U8c3RyaW5nPiB7XG4gICAgcmV0dXJuIGNhbGN1bGF0ZUhNQUMoa2V5LCBtZXNzYWdlKTtcbiAgfVxufVxuIl19

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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkBA,sCAEC;AAWD,oDAoBC;AAKD,oDAYC;AAKD,0DAkBC;AAKD,wCAkCC;AAlID,mCAAoC;AACpC,4CAA8B;AAC9B,uDAAyC;AAUzC;;;;;GAKG;AACH,SAAgB,aAAa,CAAC,GAAW,EAAE,OAAe;IACxD,OAAO,IAAA,mBAAU,EAAC,QAAQ,EAAE,GAAG,CAAC,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;AACjE,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,oBAAoB,CAAC,EACnC,OAAO,EACP,IAAI,EACJ,SAAS,EACT,UAAU,EACV,MAAM,EACN,WAAW,GACiB;IAC5B,MAAM,UAAU,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IACzC,MAAM,SAAS,GAAG,UAAU,CAAC,KAAK,IAAI,UAAU,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC;IAC1G,IAAI,UAAU,KAAK,SAAS,IAAI,QAAQ,CAAC,UAAU,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;QACrF,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;YACtB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAClF,CAAC;QACD,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,UAAU,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC5D,CAAC;IACD,IAAI,WAAW,KAAK,CAAC,EAAE,CAAC;QACtB,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;IAC7E,CAAC;IACD,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,IAAI,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAChD,CAAC;AAED;;GAEG;AACH,SAAgB,oBAAoB,CAAC,EACnC,GAAG,EAAE,OAAO,EACZ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,MAAM,EACN,WAAW,GACiB;IAC5B,MAAM,gBAAgB,GAAG,oBAAoB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IAEjG,qBAAqB;IACrB,OAAO,aAAa,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;AAChD,CAAC;AAED;;GAEG;AACH,SAAgB,uBAAuB,CAAC,EACtC,GAAG,EACH,IAAI,EACJ,KAAK,EACL,MAAM,EACN,WAAW,GACoB;IAC/B,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,IAAI,GAAG,oBAAoB,CAAC,EAAE,GAAG,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,CAAC,CAAC;IAExF,yCAAyC;IACzC,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAChD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC;IACtD,OAAO;QACL,IAAI;QACJ,SAAS;QACT,SAAS;KACV,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,SAAgB,cAAc,CAAC,EAC7B,GAAG,EAAE,OAAO,EACZ,UAAU,EACV,IAAI,EACJ,SAAS,EACT,KAAK,EACL,IAAI,EACJ,MAAM,EACN,WAAW,GACW;IACtB,MAAM,gBAAgB,GAAG,oBAAoB,CAAC;QAC5C,OAAO;QACP,IAAI;QACJ,SAAS;QACT,UAAU;QACV,MAAM;QACN,WAAW;KACZ,CAAC,CAAC;IAEH,qBAAqB;IACrB,MAAM,YAAY,GAAG,aAAa,CAAC,KAAK,EAAE,gBAAgB,CAAC,CAAC;IAE5D,kFAAkF;IAClF,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IACvB,MAAM,0BAA0B,GAAG,SAAS,IAAI,GAAG,GAAG,IAAI,GAAG,EAAE,GAAG,CAAC,IAAI,SAAS,IAAI,GAAG,CAAC;IAExF,gCAAgC;IAChC,OAAO;QACL,OAAO,EAAE,YAAY,KAAK,IAAI;QAC9B,YAAY;QACZ,gBAAgB;QAChB,0BAA0B;QAC1B,gBAAgB,EAAE,GAAG;KACtB,CAAC;AACJ,CAAC","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"}