@bitgo-beta/sdk-api 1.10.1-beta.199 → 1.10.1-beta.1990

package/dist/src/encryptV2.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HKDF_SALT_LENGTH = exports.GCM_IV_LENGTH = exports.ARGON2_DEFAULTS = void 0;
+exports.argon2ToHkdfKey = argon2ToHkdfKey;
+exports.hkdfDeriveAesKey = hkdfDeriveAesKey;
+exports.aesGcmEncrypt = aesGcmEncrypt;
+exports.aesGcmDecrypt = aesGcmDecrypt;
+exports.parseV2Envelope = parseV2Envelope;
+exports.encryptV2 = encryptV2;
+exports.decryptV2 = decryptV2;
+const argon2_1 = require("@bitgo-beta/argon2");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const crypto_1 = require("crypto");
+const t = __importStar(require("io-ts"));
+/** Web Crypto subtle — browser global in DOM; Node/Electron main must use `webcrypto`. */
+const subtle = globalThis.crypto?.subtle ?? crypto_1.webcrypto.subtle;
+/** Default Argon2id parameters per RFC 9106 second recommendation
+ * @see https://www.rfc-editor.org/rfc/rfc9106#section-4
+ */
+exports.ARGON2_DEFAULTS = {
+    memorySize: 65536, // 64 MiB in KiB
+    iterations: 3,
+    parallelism: 4,
+    hashLength: 32, // 256-bit key
+    saltLength: 16, // 128-bit salt
+};
+/** Maximum allowed Argon2id parameters to prevent DoS via crafted envelopes.
+ * memorySize: 256 MiB (4x default) -- caps memory allocation on untrusted input.
+ * iterations: 16 -- caps CPU time.
+ * parallelism: 16 -- caps thread count.
+ */
+const ARGON2_MAX = {
+    memorySize: 262144,
+    iterations: 16,
+    parallelism: 16,
+};
+/** AES-256-GCM IV length in bytes */
+exports.GCM_IV_LENGTH = 12;
+/** HKDF per-call salt length in bytes */
+exports.HKDF_SALT_LENGTH = 32;
+/** Fixed HKDF info string for domain separation across BitGo v2 session keys */
+const HKDF_INFO = new TextEncoder().encode('bitgo-v2-session');
+// Envelope codec
+const V2EnvelopeCodec = t.intersection([
+    t.type({
+        v: t.literal(2),
+        m: (0, sdk_core_1.boundedInt)(1, ARGON2_MAX.memorySize, 'memorySize'),
+        t: (0, sdk_core_1.boundedInt)(1, ARGON2_MAX.iterations, 'iterations'),
+        p: (0, sdk_core_1.boundedInt)(1, ARGON2_MAX.parallelism, 'parallelism'),
+        salt: sdk_core_1.base64String,
+        iv: sdk_core_1.base64String,
+        ct: sdk_core_1.base64String,
+    }),
+    t.partial({
+        /** Base64-encoded per-call HKDF salt -- present only in session-produced envelopes */
+        hkdfSalt: sdk_core_1.base64String,
+        /** Additional authenticated data for context binding (e.g. transaction hash + derivation path) */
+        adata: t.string,
+    }),
+]);
+// Crypto helpers
+async function argon2Hash(password, salt, params) {
+    return (0, argon2_1.argon2id)({
+        password,
+        salt,
+        memorySize: params.memorySize,
+        iterations: params.iterations,
+        parallelism: params.parallelism,
+        hashLength: exports.ARGON2_DEFAULTS.hashLength,
+        outputType: 'binary',
+    });
+}
+async function argon2ToAesKey(password, salt, params) {
+    const keyBytes = await argon2Hash(password, salt, params);
+    return subtle.importKey('raw', keyBytes, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);
+}
+async function argon2ToHkdfKey(password, salt, params) {
+    const keyBytes = await argon2Hash(password, salt, params);
+    return subtle.importKey('raw', keyBytes, 'HKDF', false, ['deriveKey']);
+}
+function hkdfDeriveAesKey(hkdfKey, hkdfSalt, usage) {
+    return subtle.deriveKey({ name: 'HKDF', hash: 'SHA-256', salt: hkdfSalt, info: HKDF_INFO }, hkdfKey, { name: 'AES-GCM', length: 256 }, false, [usage]);
+}
+async function aesGcmEncrypt(key, iv, plaintext, additionalData) {
+    const params = { name: 'AES-GCM', iv, tagLength: 128 };
+    if (additionalData)
+        params.additionalData = additionalData;
+    const ct = await subtle.encrypt(params, key, new TextEncoder().encode(plaintext));
+    return new Uint8Array(ct);
+}
+async function aesGcmDecrypt(key, iv, ct, additionalData) {
+    const params = { name: 'AES-GCM', iv, tagLength: 128 };
+    if (additionalData)
+        params.additionalData = additionalData;
+    const plaintext = await subtle.decrypt(params, key, ct);
+    return new TextDecoder().decode(plaintext);
+}
+function parseV2Envelope(ciphertext) {
+    let parsed;
+    try {
+        parsed = JSON.parse(ciphertext);
+    }
+    catch {
+        throw new Error('v2 decrypt: invalid JSON envelope');
+    }
+    return (0, sdk_core_1.decodeWithCodec)(V2EnvelopeCodec, parsed, 'v2 decrypt: invalid envelope');
+}
+// Public API
+/**
+ * Encrypt plaintext using Argon2id KDF + AES-256-GCM.
+ *
+ * Returns a self-describing JSON v2 envelope containing all Argon2id parameters,
+ * salt, IV, and ciphertext -- fully standalone for decryption.
+ *
+ * For multi-call operations (MPC signing, wallet creation), prefer
+ * createEncryptionSession to run Argon2id once and derive per-call keys via HKDF.
+ */
+async function encryptV2(password, plaintext, options) {
+    const memorySize = options?.memorySize ?? exports.ARGON2_DEFAULTS.memorySize;
+    const iterations = options?.iterations ?? exports.ARGON2_DEFAULTS.iterations;
+    const parallelism = options?.parallelism ?? exports.ARGON2_DEFAULTS.parallelism;
+    const salt = options?.salt ?? new Uint8Array((0, crypto_1.randomBytes)(exports.ARGON2_DEFAULTS.saltLength));
+    if (salt.length !== exports.ARGON2_DEFAULTS.saltLength)
+        throw new Error(`salt must be ${exports.ARGON2_DEFAULTS.saltLength} bytes`);
+    const iv = options?.iv ?? new Uint8Array((0, crypto_1.randomBytes)(exports.GCM_IV_LENGTH));
+    if (iv.length !== exports.GCM_IV_LENGTH)
+        throw new Error(`iv must be ${exports.GCM_IV_LENGTH} bytes`);
+    const adataBytes = options?.adata ? new TextEncoder().encode(options.adata) : undefined;
+    const key = await argon2ToAesKey(password, salt, { memorySize, iterations, parallelism });
+    const ct = await aesGcmEncrypt(key, iv, plaintext, adataBytes);
+    const envelope = {
+        v: 2,
+        m: memorySize,
+        t: iterations,
+        p: parallelism,
+        salt: Buffer.from(salt).toString('base64'),
+        iv: Buffer.from(iv).toString('base64'),
+        ct: Buffer.from(ct).toString('base64'),
+    };
+    if (options?.adata)
+        envelope.adata = options.adata;
+    return JSON.stringify(envelope);
+}
+/**
+ * Decrypt a v2 envelope (Argon2id + AES-256-GCM).
+ *
+ * Handles both envelope types automatically:
+ *   - Standard  (no hkdfSalt): Argon2id -> AES-GCM
+ *   - Session   (hkdfSalt present): Argon2id -> HKDF -> AES-GCM
+ *
+ * All parameters are stored in the envelope -- no session context required.
+ */
+async function decryptV2(password, ciphertext) {
+    const envelope = parseV2Envelope(ciphertext);
+    const salt = new Uint8Array(Buffer.from(envelope.salt, 'base64'));
+    const iv = new Uint8Array(Buffer.from(envelope.iv, 'base64'));
+    const ct = new Uint8Array(Buffer.from(envelope.ct, 'base64'));
+    const params = { memorySize: envelope.m, iterations: envelope.t, parallelism: envelope.p };
+    const adataBytes = envelope.adata ? new TextEncoder().encode(envelope.adata) : undefined;
+    if (envelope.hkdfSalt) {
+        const hkdfKey = await argon2ToHkdfKey(password, salt, params);
+        const hkdfSalt = new Uint8Array(Buffer.from(envelope.hkdfSalt, 'base64'));
+        const aesKey = await hkdfDeriveAesKey(hkdfKey, hkdfSalt, 'decrypt');
+        return aesGcmDecrypt(aesKey, iv, ct, adataBytes);
+    }
+    const key = await argon2ToAesKey(password, salt, params);
+    return aesGcmDecrypt(key, iv, ct, adataBytes);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryptV2.js","sourceRoot":"","sources":["../../src/encryptV2.ts"],"names":[],"mappings":"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","sourcesContent":["import { argon2id } from '@bitgo-beta/argon2';\nimport { base64String, boundedInt, decodeWithCodec } from '@bitgo-beta/sdk-core';\nimport { randomBytes, webcrypto } from 'crypto';\nimport * as t from 'io-ts';\n\n/** Web Crypto subtle — browser global in DOM; Node/Electron main must use `webcrypto`. */\nconst subtle = globalThis.crypto?.subtle ?? webcrypto.subtle;\n\n/** Default Argon2id parameters per RFC 9106 second recommendation\n * @see https://www.rfc-editor.org/rfc/rfc9106#section-4\n */\nexport const ARGON2_DEFAULTS = {\n  memorySize: 65536, // 64 MiB in KiB\n  iterations: 3,\n  parallelism: 4,\n  hashLength: 32, // 256-bit key\n  saltLength: 16, // 128-bit salt\n} as const;\n\n/** Maximum allowed Argon2id parameters to prevent DoS via crafted envelopes.\n * memorySize: 256 MiB (4x default) -- caps memory allocation on untrusted input.\n * iterations: 16 -- caps CPU time.\n * parallelism: 16 -- caps thread count.\n */\nconst ARGON2_MAX = {\n  memorySize: 262144,\n  iterations: 16,\n  parallelism: 16,\n} as const;\n\n/** AES-256-GCM IV length in bytes */\nexport const GCM_IV_LENGTH = 12;\n\n/** HKDF per-call salt length in bytes */\nexport const HKDF_SALT_LENGTH = 32;\n\n/** Fixed HKDF info string for domain separation across BitGo v2 session keys */\nconst HKDF_INFO = new TextEncoder().encode('bitgo-v2-session');\n\n// Envelope codec\n\nconst V2EnvelopeCodec = t.intersection([\n  t.type({\n    v: t.literal(2),\n    m: boundedInt(1, ARGON2_MAX.memorySize, 'memorySize'),\n    t: boundedInt(1, ARGON2_MAX.iterations, 'iterations'),\n    p: boundedInt(1, ARGON2_MAX.parallelism, 'parallelism'),\n    salt: base64String,\n    iv: base64String,\n    ct: base64String,\n  }),\n  t.partial({\n    /** Base64-encoded per-call HKDF salt -- present only in session-produced envelopes */\n    hkdfSalt: base64String,\n    /** Additional authenticated data for context binding (e.g. transaction hash + derivation path) */\n    adata: t.string,\n  }),\n]);\n\nexport type V2Envelope = t.TypeOf<typeof V2EnvelopeCodec>;\n\n// Crypto helpers\n\nasync function argon2Hash(\n  password: string,\n  salt: Uint8Array,\n  params: { memorySize: number; iterations: number; parallelism: number }\n): Promise<Uint8Array> {\n  return argon2id({\n    password,\n    salt,\n    memorySize: params.memorySize,\n    iterations: params.iterations,\n    parallelism: params.parallelism,\n    hashLength: ARGON2_DEFAULTS.hashLength,\n    outputType: 'binary',\n  });\n}\n\nasync function argon2ToAesKey(\n  password: string,\n  salt: Uint8Array,\n  params: { memorySize: number; iterations: number; parallelism: number }\n): Promise<CryptoKey> {\n  const keyBytes = await argon2Hash(password, salt, params);\n  return subtle.importKey('raw', keyBytes, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt']);\n}\n\nexport async function argon2ToHkdfKey(\n  password: string,\n  salt: Uint8Array,\n  params: { memorySize: number; iterations: number; parallelism: number }\n): Promise<CryptoKey> {\n  const keyBytes = await argon2Hash(password, salt, params);\n  return subtle.importKey('raw', keyBytes, 'HKDF', false, ['deriveKey']);\n}\n\nexport function hkdfDeriveAesKey(hkdfKey: CryptoKey, hkdfSalt: Uint8Array, usage: KeyUsage): Promise<CryptoKey> {\n  return subtle.deriveKey(\n    { name: 'HKDF', hash: 'SHA-256', salt: hkdfSalt, info: HKDF_INFO },\n    hkdfKey,\n    { name: 'AES-GCM', length: 256 },\n    false,\n    [usage]\n  );\n}\n\nexport async function aesGcmEncrypt(\n  key: CryptoKey,\n  iv: Uint8Array,\n  plaintext: string,\n  additionalData?: Uint8Array\n): Promise<Uint8Array> {\n  const params: AesGcmParams = { name: 'AES-GCM', iv, tagLength: 128 };\n  if (additionalData) params.additionalData = additionalData;\n  const ct = await subtle.encrypt(params, key, new TextEncoder().encode(plaintext));\n  return new Uint8Array(ct);\n}\n\nexport async function aesGcmDecrypt(\n  key: CryptoKey,\n  iv: Uint8Array,\n  ct: Uint8Array,\n  additionalData?: Uint8Array\n): Promise<string> {\n  const params: AesGcmParams = { name: 'AES-GCM', iv, tagLength: 128 };\n  if (additionalData) params.additionalData = additionalData;\n  const plaintext = await subtle.decrypt(params, key, ct);\n  return new TextDecoder().decode(plaintext);\n}\n\nexport function parseV2Envelope(ciphertext: string): V2Envelope {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(ciphertext);\n  } catch {\n    throw new Error('v2 decrypt: invalid JSON envelope');\n  }\n  return decodeWithCodec(V2EnvelopeCodec, parsed, 'v2 decrypt: invalid envelope');\n}\n\n// Public API\n\n/**\n * Encrypt plaintext using Argon2id KDF + AES-256-GCM.\n *\n * Returns a self-describing JSON v2 envelope containing all Argon2id parameters,\n * salt, IV, and ciphertext -- fully standalone for decryption.\n *\n * For multi-call operations (MPC signing, wallet creation), prefer\n * createEncryptionSession to run Argon2id once and derive per-call keys via HKDF.\n */\nexport async function encryptV2(\n  password: string,\n  plaintext: string,\n  options?: {\n    salt?: Uint8Array;\n    iv?: Uint8Array;\n    memorySize?: number;\n    iterations?: number;\n    parallelism?: number;\n    adata?: string;\n  }\n): Promise<string> {\n  const memorySize = options?.memorySize ?? ARGON2_DEFAULTS.memorySize;\n  const iterations = options?.iterations ?? ARGON2_DEFAULTS.iterations;\n  const parallelism = options?.parallelism ?? ARGON2_DEFAULTS.parallelism;\n\n  const salt = options?.salt ?? new Uint8Array(randomBytes(ARGON2_DEFAULTS.saltLength));\n  if (salt.length !== ARGON2_DEFAULTS.saltLength) throw new Error(`salt must be ${ARGON2_DEFAULTS.saltLength} bytes`);\n\n  const iv = options?.iv ?? new Uint8Array(randomBytes(GCM_IV_LENGTH));\n  if (iv.length !== GCM_IV_LENGTH) throw new Error(`iv must be ${GCM_IV_LENGTH} bytes`);\n\n  const adataBytes = options?.adata ? new TextEncoder().encode(options.adata) : undefined;\n  const key = await argon2ToAesKey(password, salt, { memorySize, iterations, parallelism });\n  const ct = await aesGcmEncrypt(key, iv, plaintext, adataBytes);\n\n  const envelope: V2Envelope = {\n    v: 2,\n    m: memorySize,\n    t: iterations,\n    p: parallelism,\n    salt: Buffer.from(salt).toString('base64'),\n    iv: Buffer.from(iv).toString('base64'),\n    ct: Buffer.from(ct).toString('base64'),\n  };\n  if (options?.adata) envelope.adata = options.adata;\n  return JSON.stringify(envelope);\n}\n\n/**\n * Decrypt a v2 envelope (Argon2id + AES-256-GCM).\n *\n * Handles both envelope types automatically:\n *   - Standard  (no hkdfSalt): Argon2id -> AES-GCM\n *   - Session   (hkdfSalt present): Argon2id -> HKDF -> AES-GCM\n *\n * All parameters are stored in the envelope -- no session context required.\n */\nexport async function decryptV2(password: string, ciphertext: string): Promise<string> {\n  const envelope = parseV2Envelope(ciphertext);\n  const salt = new Uint8Array(Buffer.from(envelope.salt, 'base64'));\n  const iv = new Uint8Array(Buffer.from(envelope.iv, 'base64'));\n  const ct = new Uint8Array(Buffer.from(envelope.ct, 'base64'));\n  const params = { memorySize: envelope.m, iterations: envelope.t, parallelism: envelope.p };\n  const adataBytes = envelope.adata ? new TextEncoder().encode(envelope.adata) : undefined;\n\n  if (envelope.hkdfSalt) {\n    const hkdfKey = await argon2ToHkdfKey(password, salt, params);\n    const hkdfSalt = new Uint8Array(Buffer.from(envelope.hkdfSalt, 'base64'));\n    const aesKey = await hkdfDeriveAesKey(hkdfKey, hkdfSalt, 'decrypt');\n    return aesGcmDecrypt(aesKey, iv, ct, adataBytes);\n  }\n\n  const key = await argon2ToAesKey(password, salt, params);\n  return aesGcmDecrypt(key, iv, ct, adataBytes);\n}\n"]}

package/dist/src/encryptionSession.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Runs Argon2id once on creation, then derives per-call AES-256-GCM keys via HKDF.
+ * Use when encrypting or decrypting multiple values with the same password.
+ *
+ * Session envelopes are self-describing and can be decrypted standalone via decryptV2.
+ * Call destroy() when done to clear the cached key from memory.
+ */
+export declare class EncryptionSession {
+    private hkdfKey;
+    private argon2SaltB64;
+    private readonly memorySize;
+    private readonly iterations;
+    private readonly parallelism;
+    /** Use createEncryptionSession() instead of calling this directly. */
+    constructor(hkdfKey: CryptoKey, argon2SaltB64: string, params: {
+        memorySize: number;
+        iterations: number;
+        parallelism: number;
+    });
+    encrypt(plaintext: string, adata?: string): Promise<string>;
+    decrypt(ciphertext: string): Promise<string>;
+    destroy(): void;
+    private getKeyOrThrow;
+    private getSaltOrThrow;
+    private buildEnvelope;
+}
+/** Create an EncryptionSession. Runs Argon2id once; all subsequent calls derive keys via HKDF. */
+export declare function createEncryptionSession(password: string, options?: {
+    memorySize?: number;
+    iterations?: number;
+    parallelism?: number;
+    salt?: Uint8Array;
+}): Promise<EncryptionSession>;
+//# sourceMappingURL=encryptionSession.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryptionSession.d.ts","sourceRoot":"","sources":["../../src/encryptionSession.ts"],"names":[],"mappings":"AAcA;;;;;;GAMG;AACH,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,OAAO,CAAmB;IAClC,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,sEAAsE;gBAEpE,OAAO,EAAE,SAAS,EAClB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAA;KAAE;IASnE,OAAO,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAY3D,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiBlD,OAAO,IAAI,IAAI;IAKf,OAAO,CAAC,aAAa;IAOrB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,aAAa;CAYtB;AAED,kGAAkG;AAClG,wBAAsB,uBAAuB,CAC3C,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,UAAU,CAAA;CAAE,GAC9F,OAAO,CAAC,iBAAiB,CAAC,CAe5B"}

package/dist/src/encryptionSession.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EncryptionSession = void 0;
+exports.createEncryptionSession = createEncryptionSession;
+const crypto_1 = require("crypto");
+const encryptV2_1 = require("./encryptV2");
+/**
+ * Runs Argon2id once on creation, then derives per-call AES-256-GCM keys via HKDF.
+ * Use when encrypting or decrypting multiple values with the same password.
+ *
+ * Session envelopes are self-describing and can be decrypted standalone via decryptV2.
+ * Call destroy() when done to clear the cached key from memory.
+ */
+class EncryptionSession {
+    /** Use createEncryptionSession() instead of calling this directly. */
+    constructor(hkdfKey, argon2SaltB64, params) {
+        this.hkdfKey = hkdfKey;
+        this.argon2SaltB64 = argon2SaltB64;
+        this.memorySize = params.memorySize;
+        this.iterations = params.iterations;
+        this.parallelism = params.parallelism;
+    }
+    async encrypt(plaintext, adata) {
+        const key = this.getKeyOrThrow();
+        const hkdfSalt = new Uint8Array((0, crypto_1.randomBytes)(encryptV2_1.HKDF_SALT_LENGTH));
+        const iv = new Uint8Array((0, crypto_1.randomBytes)(encryptV2_1.GCM_IV_LENGTH));
+        const adataBytes = adata ? new TextEncoder().encode(adata) : undefined;
+        const aesKey = await (0, encryptV2_1.hkdfDeriveAesKey)(key, hkdfSalt, 'encrypt');
+        const ct = await (0, encryptV2_1.aesGcmEncrypt)(aesKey, iv, plaintext, adataBytes);
+        const envelope = this.buildEnvelope(hkdfSalt, iv, ct);
+        if (adata)
+            envelope.adata = adata;
+        return JSON.stringify(envelope);
+    }
+    async decrypt(ciphertext) {
+        const key = this.getKeyOrThrow();
+        const envelope = (0, encryptV2_1.parseV2Envelope)(ciphertext);
+        if (!envelope.hkdfSalt) {
+            throw new Error('envelope was not encrypted with a session; use decryptV2 instead');
+        }
+        if (envelope.salt !== this.getSaltOrThrow()) {
+            throw new Error('envelope was not encrypted with this session');
+        }
+        const iv = new Uint8Array(Buffer.from(envelope.iv, 'base64'));
+        const ct = new Uint8Array(Buffer.from(envelope.ct, 'base64'));
+        const hkdfSalt = new Uint8Array(Buffer.from(envelope.hkdfSalt, 'base64'));
+        const adataBytes = envelope.adata ? new TextEncoder().encode(envelope.adata) : undefined;
+        const aesKey = await (0, encryptV2_1.hkdfDeriveAesKey)(key, hkdfSalt, 'decrypt');
+        return (0, encryptV2_1.aesGcmDecrypt)(aesKey, iv, ct, adataBytes);
+    }
+    destroy() {
+        this.hkdfKey = null;
+        this.argon2SaltB64 = null;
+    }
+    getKeyOrThrow() {
+        if (this.hkdfKey === null || this.argon2SaltB64 === null) {
+            throw new Error('EncryptionSession has been destroyed');
+        }
+        return this.hkdfKey;
+    }
+    getSaltOrThrow() {
+        if (this.argon2SaltB64 === null) {
+            throw new Error('EncryptionSession has been destroyed');
+        }
+        return this.argon2SaltB64;
+    }
+    buildEnvelope(hkdfSalt, iv, ct) {
+        return {
+            v: 2,
+            m: this.memorySize,
+            t: this.iterations,
+            p: this.parallelism,
+            salt: this.getSaltOrThrow(),
+            hkdfSalt: Buffer.from(hkdfSalt).toString('base64'),
+            iv: Buffer.from(iv).toString('base64'),
+            ct: Buffer.from(ct).toString('base64'),
+        };
+    }
+}
+exports.EncryptionSession = EncryptionSession;
+/** Create an EncryptionSession. Runs Argon2id once; all subsequent calls derive keys via HKDF. */
+async function createEncryptionSession(password, options) {
+    const memorySize = options?.memorySize ?? encryptV2_1.ARGON2_DEFAULTS.memorySize;
+    const iterations = options?.iterations ?? encryptV2_1.ARGON2_DEFAULTS.iterations;
+    const parallelism = options?.parallelism ?? encryptV2_1.ARGON2_DEFAULTS.parallelism;
+    const params = { memorySize, iterations, parallelism };
+    const argon2Salt = options?.salt ?? new Uint8Array((0, crypto_1.randomBytes)(encryptV2_1.ARGON2_DEFAULTS.saltLength));
+    if (argon2Salt.length !== encryptV2_1.ARGON2_DEFAULTS.saltLength) {
+        throw new Error(`salt must be ${encryptV2_1.ARGON2_DEFAULTS.saltLength} bytes`);
+    }
+    const hkdfKey = await (0, encryptV2_1.argon2ToHkdfKey)(password, argon2Salt, params);
+    const argon2SaltB64 = Buffer.from(argon2Salt).toString('base64');
+    return new EncryptionSession(hkdfKey, argon2SaltB64, params);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encryptionSession.js","sourceRoot":"","sources":["../../src/encryptionSession.ts"],"names":[],"mappings":"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","sourcesContent":["import { randomBytes } from 'crypto';\n\nimport {\n  aesGcmDecrypt,\n  aesGcmEncrypt,\n  ARGON2_DEFAULTS,\n  argon2ToHkdfKey,\n  GCM_IV_LENGTH,\n  hkdfDeriveAesKey,\n  HKDF_SALT_LENGTH,\n  parseV2Envelope,\n  V2Envelope,\n} from './encryptV2';\n\n/**\n * Runs Argon2id once on creation, then derives per-call AES-256-GCM keys via HKDF.\n * Use when encrypting or decrypting multiple values with the same password.\n *\n * Session envelopes are self-describing and can be decrypted standalone via decryptV2.\n * Call destroy() when done to clear the cached key from memory.\n */\nexport class EncryptionSession {\n  private hkdfKey: CryptoKey | null;\n  private argon2SaltB64: string | null;\n  private readonly memorySize: number;\n  private readonly iterations: number;\n  private readonly parallelism: number;\n  /** Use createEncryptionSession() instead of calling this directly. */\n  constructor(\n    hkdfKey: CryptoKey,\n    argon2SaltB64: string,\n    params: { memorySize: number; iterations: number; parallelism: number }\n  ) {\n    this.hkdfKey = hkdfKey;\n    this.argon2SaltB64 = argon2SaltB64;\n    this.memorySize = params.memorySize;\n    this.iterations = params.iterations;\n    this.parallelism = params.parallelism;\n  }\n\n  async encrypt(plaintext: string, adata?: string): Promise<string> {\n    const key = this.getKeyOrThrow();\n    const hkdfSalt = new Uint8Array(randomBytes(HKDF_SALT_LENGTH));\n    const iv = new Uint8Array(randomBytes(GCM_IV_LENGTH));\n    const adataBytes = adata ? new TextEncoder().encode(adata) : undefined;\n    const aesKey = await hkdfDeriveAesKey(key, hkdfSalt, 'encrypt');\n    const ct = await aesGcmEncrypt(aesKey, iv, plaintext, adataBytes);\n    const envelope = this.buildEnvelope(hkdfSalt, iv, ct);\n    if (adata) envelope.adata = adata;\n    return JSON.stringify(envelope);\n  }\n\n  async decrypt(ciphertext: string): Promise<string> {\n    const key = this.getKeyOrThrow();\n    const envelope = parseV2Envelope(ciphertext);\n    if (!envelope.hkdfSalt) {\n      throw new Error('envelope was not encrypted with a session; use decryptV2 instead');\n    }\n    if (envelope.salt !== this.getSaltOrThrow()) {\n      throw new Error('envelope was not encrypted with this session');\n    }\n    const iv = new Uint8Array(Buffer.from(envelope.iv, 'base64'));\n    const ct = new Uint8Array(Buffer.from(envelope.ct, 'base64'));\n    const hkdfSalt = new Uint8Array(Buffer.from(envelope.hkdfSalt, 'base64'));\n    const adataBytes = envelope.adata ? new TextEncoder().encode(envelope.adata) : undefined;\n    const aesKey = await hkdfDeriveAesKey(key, hkdfSalt, 'decrypt');\n    return aesGcmDecrypt(aesKey, iv, ct, adataBytes);\n  }\n\n  destroy(): void {\n    this.hkdfKey = null;\n    this.argon2SaltB64 = null;\n  }\n\n  private getKeyOrThrow(): CryptoKey {\n    if (this.hkdfKey === null || this.argon2SaltB64 === null) {\n      throw new Error('EncryptionSession has been destroyed');\n    }\n    return this.hkdfKey;\n  }\n\n  private getSaltOrThrow(): string {\n    if (this.argon2SaltB64 === null) {\n      throw new Error('EncryptionSession has been destroyed');\n    }\n    return this.argon2SaltB64;\n  }\n\n  private buildEnvelope(hkdfSalt: Uint8Array, iv: Uint8Array, ct: Uint8Array): V2Envelope {\n    return {\n      v: 2,\n      m: this.memorySize,\n      t: this.iterations,\n      p: this.parallelism,\n      salt: this.getSaltOrThrow(),\n      hkdfSalt: Buffer.from(hkdfSalt).toString('base64'),\n      iv: Buffer.from(iv).toString('base64'),\n      ct: Buffer.from(ct).toString('base64'),\n    };\n  }\n}\n\n/** Create an EncryptionSession. Runs Argon2id once; all subsequent calls derive keys via HKDF. */\nexport async function createEncryptionSession(\n  password: string,\n  options?: { memorySize?: number; iterations?: number; parallelism?: number; salt?: Uint8Array }\n): Promise<EncryptionSession> {\n  const memorySize = options?.memorySize ?? ARGON2_DEFAULTS.memorySize;\n  const iterations = options?.iterations ?? ARGON2_DEFAULTS.iterations;\n  const parallelism = options?.parallelism ?? ARGON2_DEFAULTS.parallelism;\n  const params = { memorySize, iterations, parallelism };\n\n  const argon2Salt = options?.salt ?? new Uint8Array(randomBytes(ARGON2_DEFAULTS.saltLength));\n  if (argon2Salt.length !== ARGON2_DEFAULTS.saltLength) {\n    throw new Error(`salt must be ${ARGON2_DEFAULTS.saltLength} bytes`);\n  }\n\n  const hkdfKey = await argon2ToHkdfKey(password, argon2Salt, params);\n  const argon2SaltB64 = Buffer.from(argon2Salt).toString('base64');\n\n  return new EncryptionSession(hkdfKey, argon2SaltB64, params);\n}\n"]}

package/dist/src/index.d.ts

@@ -1,6 +1,9 @@
 export * from './api';
 export * from './bitgoAPI';
+export * from './decryptV1';
 export * from './encrypt';
+export * from './encryptionSession';
+export * from './encryptV2';
 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,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC;AAC1B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC;AACtB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,WAAW,CAAC;AAC1B,cAAc,qBAAqB,CAAC;AACpC,cAAc,aAAa,CAAC;AAC5B,cAAc,QAAQ,CAAC;AACvB,cAAc,SAAS,CAAC"}

package/dist/src/index.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];
@@ -12,7 +16,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./api"), exports);
 __exportStar(require("./bitgoAPI"), exports);
+__exportStar(require("./decryptV1"), exports);
 __exportStar(require("./encrypt"), exports);
+__exportStar(require("./encryptionSession"), exports);
+__exportStar(require("./encryptV2"), exports);
 __exportStar(require("./util"), exports);
 __exportStar(require("./types"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsd0NBQXNCO0FBQ3RCLDZDQUEyQjtBQUMzQiw0Q0FBMEI7QUFDMUIseUNBQXVCO0FBQ3ZCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vYml0Z29BUEknO1xuZXhwb3J0ICogZnJvbSAnLi9lbmNyeXB0JztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQjtBQUN0Qiw2Q0FBMkI7QUFDM0IsOENBQTRCO0FBQzVCLDRDQUEwQjtBQUMxQixzREFBb0M7QUFDcEMsOENBQTRCO0FBQzVCLHlDQUF1QjtBQUN2QiwwQ0FBd0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2FwaSc7XG5leHBvcnQgKiBmcm9tICcuL2JpdGdvQVBJJztcbmV4cG9ydCAqIGZyb20gJy4vZGVjcnlwdFYxJztcbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdCc7XG5leHBvcnQgKiBmcm9tICcuL2VuY3J5cHRpb25TZXNzaW9uJztcbmV4cG9ydCAqIGZyb20gJy4vZW5jcnlwdFYyJztcbmV4cG9ydCAqIGZyb20gJy4vdXRpbCc7XG5leHBvcnQgKiBmcm9tICcuL3R5cGVzJztcbiJdfQ==

package/dist/src/types.d.ts

@@ -1,8 +1,23 @@
-import { EnvironmentName, IRequestTracer, V1Network } from '@bitgo-beta/sdk-core';
+import { EncryptionVersion, EnvironmentName, IRequestTracer, V1Network } from '@bitgo-beta/sdk-core';
 import { ECPairInterface } from '@bitgo-beta/utxo-lib';
+import { type Agent } from 'http';
+export type Constants = Record<string, any>;
+declare const patchedRequestMethods: readonly ["get", "post", "put", "del", "patch", "options"];
+export type RequestMethods = (typeof patchedRequestMethods)[number];
+export type AdditionalHeadersCallback = (method: RequestMethods, url: string, data?: string) => Array<{
+    key: string;
+    value: string;
+}>;
+export { AuthVersion, CalculateHmacSubjectOptions, CalculateRequestHeadersOptions, CalculateRequestHmacOptions, IHmacAuthStrategy, RequestHeaders, supportedRequestMethods, VerifyResponseInfo, VerifyResponseOptions, } from '@bitgo-beta/sdk-hmac';
+import type { IHmacAuthStrategy } from '@bitgo-beta/sdk-hmac';
 export interface BitGoAPIOptions {
     accessToken?: string;
     authVersion?: 2 | 3;
+    hmacAuthStrategy?: IHmacAuthStrategy;
+    clientConstants?: Record<string, any> | {
+        constants: Record<string, any>;
+        ttl?: number;
+    };
     customBitcoinNetwork?: V1Network;
     customRootURI?: string;
     customSigningAddress?: string;
@@ -11,10 +26,23 @@ export interface BitGoAPIOptions {
     env?: EnvironmentName;
     etherscanApiToken?: string;
     polygonscanApiToken?: string;
+    baseethApiToken?: string;
     arbiscanApiToken?: string;
     optimisticEtherscanApiToken?: string;
+    zksyncExplorerApiToken?: string;
+    bscscanApiToken?: string;
+    coredaoExplorerApiToken?: string;
+    oasExplorerApiToken?: string;
+    sgbExplorerApiToken?: string;
+    flrExplorerApiToken?: string;
+    xdcExplorerApiToken?: string;
+    wemixExplorerApiToken?: string;
+    monExplorerApiToken?: string;
+    worldExplorerApiToken?: string;
+    somniaExplorerApiToken?: string;
+    soneiumExplorerApiToken?: string;
     hmacVerification?: boolean;
-    proxy?: string;
+    customProxyAgent?: Agent;
     refreshToken?: string;
     serverXpub?: string;
     stellarFederationServerUrl?: string;
@@ -22,6 +50,14 @@ export interface BitGoAPIOptions {
     userAgent?: string;
     validate?: boolean;
     cookiesPropagationEnabled?: boolean;
+    getAdditionalHeadersCb?: AdditionalHeadersCallback;
+    requestIdPrefix?: string;
+    evm?: {
+        [key: string]: {
+            baseUrl?: string;
+            apiToken?: string;
+        };
+    };
 }
 export interface AccessTokenOptions {
     accessToken: string;
@@ -29,47 +65,6 @@ export interface AccessTokenOptions {
 export interface PingOptions {
     reqId?: IRequestTracer;
 }
-export declare const supportedRequestMethods: readonly ["get", "post", "put", "del", "patch"];
-export interface CalculateHmacSubjectOptions {
-    urlPath: string;
-    text: string;
-    timestamp: number;
-    method: (typeof supportedRequestMethods)[number];
-    statusCode?: number;
-}
-export interface CalculateRequestHmacOptions {
-    url: string;
-    text: string;
-    timestamp: number;
-    token: string;
-    method: (typeof supportedRequestMethods)[number];
-}
-export interface RequestHeaders {
-    hmac: string;
-    timestamp: number;
-    tokenHash: string;
-}
-export interface CalculateRequestHeadersOptions {
-    url: string;
-    text: string;
-    token: string;
-    method: (typeof supportedRequestMethods)[number];
-}
-export interface VerifyResponseOptions extends CalculateRequestHeadersOptions {
-    hmac: string;
-    url: string;
-    text: string;
-    timestamp: number;
-    method: (typeof supportedRequestMethods)[number];
-    statusCode?: number;
-}
-export interface VerifyResponseInfo {
-    isValid: boolean;
-    expectedHmac: string;
-    signatureSubject: string;
-    isInResponseValidityWindow: boolean;
-    verificationTime: number;
-}
 export interface AuthenticateOptions {
     username: string;
     password: string;
@@ -88,6 +83,26 @@ export interface AuthenticateOptions {
      * It is highly recommended that this is always set to avoid any issues when using a BitGo wallet
      */
     ensureEcdhKeychain?: boolean;
+    /**
+     * Encryption version to use when creating the ECDH keychain if it does not already exist.
+     * Only applies when `ensureEcdhKeychain` is true and no ECDH keychain exists for the user yet.
+     */
+    encryptionVersion?: EncryptionVersion;
+    forReset2FA?: boolean;
+    /**
+     * The initial stage fingerprint hash used for device identification and verification.
+     * @type {string}
+     * @default undefined
+     * @description An SHA-256 hash string generated from device-specific attributes
+     */
+    initialHash?: string;
+    /**
+     * The final stage fingerprint hash used for trusted device verification.
+     * @type {string}
+     * @default undefined
+     * @description An SHA-256 hash string derived from the initialHash and verification code
+     */
+    fingerprintHash?: string;
 }
 export interface ProcessedAuthenticationOptions {
     email: string;
@@ -98,6 +113,9 @@ export interface ProcessedAuthenticationOptions {
     extensible?: boolean;
     extensionAddress?: string;
     forceV1Auth?: boolean;
+    forReset2FA?: boolean;
+    initialHash?: string;
+    fingerprintHash?: string;
 }
 export interface User {
     username: string;
@@ -125,6 +143,7 @@ export interface AccessTokenSpendingLimit {
     txCount?: number;
     txValue?: string;
     txValueLimit?: string;
+    maxLimit?: boolean;
 }
 export interface AddAccessTokenOptions {
     label: string;
@@ -134,6 +153,7 @@ export interface AddAccessTokenOptions {
     txValueLimit?: number;
     scope: string[];
     spendingLimits?: AccessTokenSpendingLimit[];
+    enterprise?: string;
 }
 export interface AddAccessTokenResponse {
     id: string;
@@ -177,6 +197,7 @@ export interface SplitSecretOptions {
     seed: string;
     passwords: string[];
     m: number;
+    encryptionVersion?: EncryptionVersion;
 }
 export interface SplitSecret {
     xpub: string;
@@ -206,6 +227,12 @@ export interface GetEcdhSecretOptions {
 export interface ChangePasswordOptions {
     oldPassword: string;
     newPassword: string;
+    /**
+     * Envelope version to emit for the re-encrypted keychains. Defaults to preserving each
+     * keychain's existing envelope version (no forced migration). Pass `2` to opt in to the
+     * Argon2id upgrade for v1 (SJCL) keychains once the caller is ready.
+     */
+    encryptionVersion?: EncryptionVersion;
 }
 /**
  * @deprecated