@bitgo/sdk-api 2.3.2 → 2.4.1

package/dist/test/unit/decryptV1.js

@@ -0,0 +1,230 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sjcl = __importStar(require("@bitgo/sjcl"));
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = require("crypto");
+const src_1 = require("../../src");
+const keycard_1 = require("./fixtures/keycard");
+/**
+ * sjcl.encrypt's typings require salt/iv, but the runtime picks them from
+ * sjcl.random when omitted. Feed real random words so the call type-checks
+ * without an `as` cast.
+ */
+function sjclEncrypt(password, plaintext, params) {
+    const salt = sjcl.random.randomWords(2); // 8 bytes
+    const iv = sjcl.random.randomWords(4); // 16 bytes
+    return sjcl.encrypt(password, plaintext, { ...params, salt, iv });
+}
+describe('decryptV1 (native, SJCL-free)', () => {
+    const password = 'myPassword';
+    const plaintext = 'Hello, World!';
+    describe('parity with SJCL', () => {
+        it('matches sjcl.decrypt output for the same envelope', async () => {
+            const ciphertext = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(password, ciphertext), sjcl.decrypt(password, ciphertext));
+        });
+        it('decrypts with adata (AAD)', async () => {
+            const ciphertext = sjclEncrypt(password, plaintext, {
+                iter: 10000,
+                ks: 256,
+                ts: 64,
+                mode: 'ccm',
+                adata: 'context-A',
+            });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(password, ciphertext), plaintext);
+        });
+        it('decrypts UTF-8 password + plaintext', async () => {
+            const utf8Password = 'pässwörd中文🔐';
+            const utf8Plaintext = 'passphrase: 秘密キー ☃🔑';
+            const ciphertext = sjclEncrypt(utf8Password, utf8Plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(utf8Password, ciphertext), utf8Plaintext);
+        });
+        it('decrypts large plaintext (>64 KiB, forces L=3 nonce framing)', async () => {
+            const large = 'x'.repeat(70000);
+            const ciphertext = sjclEncrypt(password, large, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(password, ciphertext), large);
+        });
+        it('decrypts aes-128 envelopes', async () => {
+            const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 128, ts: 64, mode: 'ccm' });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(password, ciphertext), plaintext);
+        });
+        it('decrypts envelopes with 128-bit tag size', async () => {
+            const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 128, mode: 'ccm' });
+            assert_1.default.strictEqual(await (0, src_1.decryptV1)(password, ciphertext), plaintext);
+        });
+        it('parity across 50 randomised inputs', async () => {
+            for (let i = 0; i < 50; i++) {
+                const pw = (0, crypto_1.randomBytes)(16).toString('hex');
+                const pt = (0, crypto_1.randomBytes)(1 + Math.floor(Math.random() * 500)).toString('base64');
+                const ciphertext = sjclEncrypt(pw, pt, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });
+                assert_1.default.strictEqual(await (0, src_1.decryptV1)(pw, ciphertext), pt, `iteration ${i}`);
+            }
+        });
+    });
+    describe('failure modes', () => {
+        it('throws on wrong password', async () => {
+            const ciphertext = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            await assert_1.default.rejects(() => (0, src_1.decryptV1)('wrongPassword', ciphertext));
+        });
+        it('throws on invalid JSON', async () => {
+            await assert_1.default.rejects(() => (0, src_1.decryptV1)(password, 'not-json'), /invalid JSON envelope/);
+        });
+        it('rejects malformed envelope (representative codec check)', async () => {
+            const envelope = JSON.parse(await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 }));
+            envelope.mode = 'gcm';
+            await assert_1.default.rejects(() => (0, src_1.decryptV1)(password, JSON.stringify(envelope)), /invalid envelope/);
+        });
+        it('rejects tampered ciphertext (auth-tag mismatch)', async () => {
+            const ciphertext = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            const envelope = JSON.parse(ciphertext);
+            const tampered = Buffer.from(envelope.ct, 'base64');
+            tampered[0] ^= 0x01;
+            envelope.ct = tampered.toString('base64');
+            await assert_1.default.rejects(() => (0, src_1.decryptV1)(password, JSON.stringify(envelope)));
+        });
+    });
+    describe('iter cap enforcement', () => {
+        it('rejects an envelope with iter above V1_MAX_ITER before running PBKDF2', async () => {
+            const envelope = JSON.parse(await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 }));
+            envelope.iter = src_1.V1_MAX_ITER + 1;
+            const start = Date.now();
+            await assert_1.default.rejects(() => (0, src_1.decryptV1)(password, JSON.stringify(envelope)), /iter/);
+            assert_1.default.ok(Date.now() - start < 100, 'must reject before any KDF work');
+        });
+    });
+    describe('real BitGo keycard parity', () => {
+        it('Box A: native decrypt matches SJCL byte-for-byte', async () => {
+            const sjclResult = sjcl.decrypt(keycard_1.KEYCARD_PASSWORD, keycard_1.KEYCARD_BOX_A);
+            const nativeResult = await (0, src_1.decryptV1)(keycard_1.KEYCARD_PASSWORD, keycard_1.KEYCARD_BOX_A);
+            assert_1.default.strictEqual(nativeResult, sjclResult);
+            assert_1.default.strictEqual(nativeResult.length, keycard_1.KEYCARD_BOX_A_LENGTH);
+            assert_1.default.ok(nativeResult.startsWith(keycard_1.KEYCARD_PLAINTEXT_PREFIX));
+        });
+        it('Box B: native decrypt matches SJCL byte-for-byte', async () => {
+            const sjclResult = sjcl.decrypt(keycard_1.KEYCARD_PASSWORD, keycard_1.KEYCARD_BOX_B);
+            const nativeResult = await (0, src_1.decryptV1)(keycard_1.KEYCARD_PASSWORD, keycard_1.KEYCARD_BOX_B);
+            assert_1.default.strictEqual(nativeResult, sjclResult);
+            assert_1.default.strictEqual(nativeResult.length, keycard_1.KEYCARD_BOX_B_LENGTH);
+            assert_1.default.ok(nativeResult.startsWith(keycard_1.KEYCARD_PLAINTEXT_PREFIX));
+        });
+    });
+    describe('SJCL fallback behavior', () => {
+        // Rollout contract:
+        // - Native success -> no warn, no fallback.
+        // - Iter cap violation -> rethrown (no fallback), preserves DoS protection.
+        // - Both engines fail (e.g. wrong password) -> SJCL error rethrown, NO warn.
+        // - Native fails, SJCL succeeds -> return SJCL result + warn (engines disagree).
+        // eslint-disable-next-line no-console
+        const originalWarn = console.warn;
+        let warnings = [];
+        beforeEach(() => {
+            warnings = [];
+            // eslint-disable-next-line no-console
+            console.warn = (...args) => {
+                warnings.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));
+            };
+        });
+        afterEach(() => {
+            // eslint-disable-next-line no-console
+            console.warn = originalWarn;
+        });
+        it('success path emits no console.warn', async () => {
+            const ct = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            await (0, src_1.decrypt)(password, ct);
+            assert_1.default.deepStrictEqual(warnings, []);
+        });
+        it('iter cap violation rethrows and does not warn', async () => {
+            const envelope = JSON.parse(await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 }));
+            envelope.iter = src_1.V1_MAX_ITER + 1;
+            await assert_1.default.rejects(() => (0, src_1.decrypt)(password, JSON.stringify(envelope)), /iter/);
+            assert_1.default.deepStrictEqual(warnings, []);
+        });
+        it('wrong password does not warn (both engines fail, SJCL error rethrown)', async () => {
+            const ct = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            await assert_1.default.rejects(() => (0, src_1.decrypt)('wrong', ct));
+            assert_1.default.deepStrictEqual(warnings, []);
+        });
+        it('warns and returns SJCL result when native fails but SJCL succeeds', async () => {
+            const ct = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            const brokenNative = async () => {
+                throw new Error('unsupported algorithm');
+            };
+            const result = await (0, src_1.decryptV1WithFallback)(password, ct, brokenNative);
+            assert_1.default.strictEqual(result, plaintext);
+            assert_1.default.strictEqual(warnings.length, 1);
+            assert_1.default.ok(warnings[0].includes('SJCL fallback succeeded'));
+        });
+    });
+    describe('browser runtime (isBrowser = true)', () => {
+        it('skips native and decrypts via SJCL without warning', async () => {
+            const ct = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            const neverCalled = async () => {
+                throw new Error('native should not be attempted in the browser');
+            };
+            // eslint-disable-next-line no-console
+            const originalWarn = console.warn;
+            const warnings = [];
+            // eslint-disable-next-line no-console
+            console.warn = (...args) => {
+                warnings.push(args.join(' '));
+            };
+            try {
+                const result = await (0, src_1.decryptV1WithFallback)(password, ct, neverCalled, true);
+                assert_1.default.strictEqual(result, plaintext);
+                assert_1.default.deepStrictEqual(warnings, []);
+            }
+            finally {
+                // eslint-disable-next-line no-console
+                console.warn = originalWarn;
+            }
+        });
+        it('still enforces the iter cap before running PBKDF2', async () => {
+            const envelope = JSON.parse(await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 }));
+            envelope.iter = src_1.V1_MAX_ITER + 1;
+            const start = Date.now();
+            await assert_1.default.rejects(() => (0, src_1.decryptV1WithFallback)(password, JSON.stringify(envelope), src_1.decryptV1, true), /iter/);
+            assert_1.default.ok(Date.now() - start < 100, 'must reject before any KDF work');
+        });
+        it('rejects wrong password via SJCL auth failure', async () => {
+            const ct = await (0, src_1.encrypt)(password, plaintext, { encryptionVersion: 1 });
+            await assert_1.default.rejects(() => (0, src_1.decryptV1WithFallback)('wrongPassword', ct, src_1.decryptV1, true));
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"decryptV1.js","sourceRoot":"","sources":["../../../test/unit/decryptV1.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sjcl from '@bitgo/sjcl';\nimport assert from 'assert';\nimport { randomBytes } from 'crypto';\n\nimport { decrypt, decryptV1, decryptV1WithFallback, encrypt, V1_MAX_ITER } from '../../src';\nimport {\n  KEYCARD_BOX_A,\n  KEYCARD_BOX_A_LENGTH,\n  KEYCARD_BOX_B,\n  KEYCARD_BOX_B_LENGTH,\n  KEYCARD_PASSWORD,\n  KEYCARD_PLAINTEXT_PREFIX,\n} from './fixtures/keycard';\n\n/**\n * sjcl.encrypt's typings require salt/iv, but the runtime picks them from\n * sjcl.random when omitted. Feed real random words so the call type-checks\n * without an `as` cast.\n */\nfunction sjclEncrypt(password: string, plaintext: string, params: sjcl.SjclCipherParams): string {\n  const salt = sjcl.random.randomWords(2); // 8 bytes\n  const iv = sjcl.random.randomWords(4); // 16 bytes\n  return sjcl.encrypt(password, plaintext, { ...params, salt, iv });\n}\n\ndescribe('decryptV1 (native, SJCL-free)', () => {\n  const password = 'myPassword';\n  const plaintext = 'Hello, World!';\n\n  describe('parity with SJCL', () => {\n    it('matches sjcl.decrypt output for the same envelope', async () => {\n      const ciphertext = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      assert.strictEqual(await decryptV1(password, ciphertext), sjcl.decrypt(password, ciphertext));\n    });\n\n    it('decrypts with adata (AAD)', async () => {\n      const ciphertext = sjclEncrypt(password, plaintext, {\n        iter: 10000,\n        ks: 256,\n        ts: 64,\n        mode: 'ccm',\n        adata: 'context-A',\n      });\n      assert.strictEqual(await decryptV1(password, ciphertext), plaintext);\n    });\n\n    it('decrypts UTF-8 password + plaintext', async () => {\n      const utf8Password = 'pässwörd中文🔐';\n      const utf8Plaintext = 'passphrase: 秘密キー ☃🔑';\n      const ciphertext = sjclEncrypt(utf8Password, utf8Plaintext, { iter: 10000, ks: 256, ts: 64, mode: 'ccm' });\n      assert.strictEqual(await decryptV1(utf8Password, ciphertext), utf8Plaintext);\n    });\n\n    it('decrypts large plaintext (>64 KiB, forces L=3 nonce framing)', async () => {\n      const large = 'x'.repeat(70_000);\n      const ciphertext = sjclEncrypt(password, large, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });\n      assert.strictEqual(await decryptV1(password, ciphertext), large);\n    });\n\n    it('decrypts aes-128 envelopes', async () => {\n      const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 128, ts: 64, mode: 'ccm' });\n      assert.strictEqual(await decryptV1(password, ciphertext), plaintext);\n    });\n\n    it('decrypts envelopes with 128-bit tag size', async () => {\n      const ciphertext = sjclEncrypt(password, plaintext, { iter: 10000, ks: 256, ts: 128, mode: 'ccm' });\n      assert.strictEqual(await decryptV1(password, ciphertext), plaintext);\n    });\n\n    it('parity across 50 randomised inputs', async () => {\n      for (let i = 0; i < 50; i++) {\n        const pw = randomBytes(16).toString('hex');\n        const pt = randomBytes(1 + Math.floor(Math.random() * 500)).toString('base64');\n        const ciphertext = sjclEncrypt(pw, pt, { iter: 1000, ks: 256, ts: 64, mode: 'ccm' });\n        assert.strictEqual(await decryptV1(pw, ciphertext), pt, `iteration ${i}`);\n      }\n    });\n  });\n\n  describe('failure modes', () => {\n    it('throws on wrong password', async () => {\n      const ciphertext = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      await assert.rejects(() => decryptV1('wrongPassword', ciphertext));\n    });\n\n    it('throws on invalid JSON', async () => {\n      await assert.rejects(() => decryptV1(password, 'not-json'), /invalid JSON envelope/);\n    });\n\n    it('rejects malformed envelope (representative codec check)', async () => {\n      const envelope = JSON.parse(await encrypt(password, plaintext, { encryptionVersion: 1 }));\n      envelope.mode = 'gcm';\n      await assert.rejects(() => decryptV1(password, JSON.stringify(envelope)), /invalid envelope/);\n    });\n\n    it('rejects tampered ciphertext (auth-tag mismatch)', async () => {\n      const ciphertext = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      const envelope = JSON.parse(ciphertext);\n      const tampered = Buffer.from(envelope.ct, 'base64');\n      tampered[0] ^= 0x01;\n      envelope.ct = tampered.toString('base64');\n      await assert.rejects(() => decryptV1(password, JSON.stringify(envelope)));\n    });\n  });\n\n  describe('iter cap enforcement', () => {\n    it('rejects an envelope with iter above V1_MAX_ITER before running PBKDF2', async () => {\n      const envelope = JSON.parse(await encrypt(password, plaintext, { encryptionVersion: 1 }));\n      envelope.iter = V1_MAX_ITER + 1;\n      const start = Date.now();\n      await assert.rejects(() => decryptV1(password, JSON.stringify(envelope)), /iter/);\n      assert.ok(Date.now() - start < 100, 'must reject before any KDF work');\n    });\n  });\n\n  describe('real BitGo keycard parity', () => {\n    it('Box A: native decrypt matches SJCL byte-for-byte', async () => {\n      const sjclResult = sjcl.decrypt(KEYCARD_PASSWORD, KEYCARD_BOX_A);\n      const nativeResult = await decryptV1(KEYCARD_PASSWORD, KEYCARD_BOX_A);\n      assert.strictEqual(nativeResult, sjclResult);\n      assert.strictEqual(nativeResult.length, KEYCARD_BOX_A_LENGTH);\n      assert.ok(nativeResult.startsWith(KEYCARD_PLAINTEXT_PREFIX));\n    });\n\n    it('Box B: native decrypt matches SJCL byte-for-byte', async () => {\n      const sjclResult = sjcl.decrypt(KEYCARD_PASSWORD, KEYCARD_BOX_B);\n      const nativeResult = await decryptV1(KEYCARD_PASSWORD, KEYCARD_BOX_B);\n      assert.strictEqual(nativeResult, sjclResult);\n      assert.strictEqual(nativeResult.length, KEYCARD_BOX_B_LENGTH);\n      assert.ok(nativeResult.startsWith(KEYCARD_PLAINTEXT_PREFIX));\n    });\n  });\n\n  describe('SJCL fallback behavior', () => {\n    // Rollout contract:\n    // - Native success -> no warn, no fallback.\n    // - Iter cap violation -> rethrown (no fallback), preserves DoS protection.\n    // - Both engines fail (e.g. wrong password) -> SJCL error rethrown, NO warn.\n    // - Native fails, SJCL succeeds -> return SJCL result + warn (engines disagree).\n\n    // eslint-disable-next-line no-console\n    const originalWarn = console.warn;\n    let warnings: string[] = [];\n\n    beforeEach(() => {\n      warnings = [];\n      // eslint-disable-next-line no-console\n      console.warn = (...args: unknown[]) => {\n        warnings.push(args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a))).join(' '));\n      };\n    });\n\n    afterEach(() => {\n      // eslint-disable-next-line no-console\n      console.warn = originalWarn;\n    });\n\n    it('success path emits no console.warn', async () => {\n      const ct = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      await decrypt(password, ct);\n      assert.deepStrictEqual(warnings, []);\n    });\n\n    it('iter cap violation rethrows and does not warn', async () => {\n      const envelope = JSON.parse(await encrypt(password, plaintext, { encryptionVersion: 1 }));\n      envelope.iter = V1_MAX_ITER + 1;\n      await assert.rejects(() => decrypt(password, JSON.stringify(envelope)), /iter/);\n      assert.deepStrictEqual(warnings, []);\n    });\n\n    it('wrong password does not warn (both engines fail, SJCL error rethrown)', async () => {\n      const ct = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      await assert.rejects(() => decrypt('wrong', ct));\n      assert.deepStrictEqual(warnings, []);\n    });\n\n    it('warns and returns SJCL result when native fails but SJCL succeeds', async () => {\n      const ct = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      const brokenNative = async () => {\n        throw new Error('unsupported algorithm');\n      };\n      const result = await decryptV1WithFallback(password, ct, brokenNative);\n      assert.strictEqual(result, plaintext);\n      assert.strictEqual(warnings.length, 1);\n      assert.ok(warnings[0].includes('SJCL fallback succeeded'));\n    });\n  });\n\n  describe('browser runtime (isBrowser = true)', () => {\n    it('skips native and decrypts via SJCL without warning', async () => {\n      const ct = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      const neverCalled = async (): Promise<string> => {\n        throw new Error('native should not be attempted in the browser');\n      };\n      // eslint-disable-next-line no-console\n      const originalWarn = console.warn;\n      const warnings: string[] = [];\n      // eslint-disable-next-line no-console\n      console.warn = (...args: unknown[]) => {\n        warnings.push(args.join(' '));\n      };\n      try {\n        const result = await decryptV1WithFallback(password, ct, neverCalled, true);\n        assert.strictEqual(result, plaintext);\n        assert.deepStrictEqual(warnings, []);\n      } finally {\n        // eslint-disable-next-line no-console\n        console.warn = originalWarn;\n      }\n    });\n\n    it('still enforces the iter cap before running PBKDF2', async () => {\n      const envelope = JSON.parse(await encrypt(password, plaintext, { encryptionVersion: 1 }));\n      envelope.iter = V1_MAX_ITER + 1;\n      const start = Date.now();\n      await assert.rejects(() => decryptV1WithFallback(password, JSON.stringify(envelope), decryptV1, true), /iter/);\n      assert.ok(Date.now() - start < 100, 'must reject before any KDF work');\n    });\n\n    it('rejects wrong password via SJCL auth failure', async () => {\n      const ct = await encrypt(password, plaintext, { encryptionVersion: 1 });\n      await assert.rejects(() => decryptV1WithFallback('wrongPassword', ct, decryptV1, true));\n    });\n  });\n});\n"]}

package/dist/test/unit/fixtures/keycard.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fixtures for real-world v1 decrypt parity tests.
+ *
+ * These come from a purpose-built BitGo test keycard (wallet name: "sol")
+ * created 2026-08-14 solely for this test suite. The wallet is a throwaway
+ * testnet Solana wallet with no real funds; the ciphertexts, wallet, and
+ * password below are safe to check in.
+ *
+ * Boxes A + B are the user and backup MPC key shares (uShare), encrypted
+ * client-side with the wallet password using the exact envelope shape BitGo
+ * produces in production (`iter=10000, ks=256, ts=64, mode=ccm, cipher=aes,
+ * adata=""`).
+ *
+ * Purpose: catch any regression where the native/shim decrypt paths diverge
+ * from SJCL on real production-shaped envelopes.
+ */
+export declare const KEYCARD_PASSWORD = "97IoV9Qs3fuhBKYCg6ju0y6LPBHTywBY";
+export declare const KEYCARD_BOX_A = "{\"iv\":\"iury+nZhVfoWjpzbzrN1Yw==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"WiUMqHlpxiQ=\",\"ct\":\"Qx6nr/Q+oEaHmmsIq75cHcR4hR4XzowpJvdgNuzcGD6v113dimT8tg2FAWAGj+syRfH19X5cDBhFX6k3ifWMbyQHneHs0OGh86kjm/v4ddNHaGgGEzhsQCWX2tAOyhxT+oG5PewnSr+xFGZePvo0GFakmPFLzF9gfvG8K3o30i0iU5UyzPdp5iAZGbZTseqp6d3KXcleA712Gnv5eT0mlDYJwoi9Io7TwCjdaa2M5r1PFkN8ZaC1aIzba3A+f7b7PDrfFckGGDIl6o2ytjNEpCKvvbfiTbk9/WOIXtMibW1e3ysmuPl5tiw2lSAtYXHQOl9rqwEvtoIMtM2uZqAE+ELf8UiabdBpdCYFiSVBgD+jjEfgUocd7xCRh2bW/Uqhu8ye7SDdZowMaTI3d/sGW8QubquPaHWQZTkhvDXttT0l1YXsIld3L2mQfDw+FpFD+SihNDiCf4fVYHFI/I9bYMx03QnUV+wXyo0dl1QXnkyVxTVOeaoJ7dM7Tp7h5cY2m5Dlp2YvAY2twRzOSPKjYu8M+rUuY0GsbodZW8mKXCLVfTyNmonSgqmLZ7V8MlZ4oR2gGfPn39XrGG9fRPj3lKb4gaFCSweHWfXAAXLN+MP9BquE57cphKn8RcuwwGPnH0j/tKOdcqKtn1XcAKtf8+s3L7utIXS+dijADqTLrjfG/2gKe4NbpykiW/vOPQ+2BbZO7d0F0YMnd2di/KD2VL5Y3M6Iib1zZAQX1r41X9Zb1/ShEsKtFyObi2zG0atYrQ6g4+f11nBbwJa6BD6n3P+UAaHvIJoXEFnaccvq3OWowlHQppQUOqCkdg5kwf2fXJqkR9hGGSBpXM48gm61hgwR12n2rDQxks6wwtdtm5BMKZrJy25x/ZAqYaQejm+0dT9SVa0qpNNOa1IdDzrPnI0AL1aLNGOVQ9EwEt9OOYoS/DBTp7JmVwhShDC5w8Br3KOKsm5qlWz/uslhfWBR7l6+BFft2jjfeCmfjZORCuhV5tX5nnQXuc13HjQkrdzaJE+LXZYtal+U83i2SfdwZnWuplTQqxKk+C0ikfGGJd7PDNb+8VEoR3rEIXk4YKJyI/HyPAVwNJN48tm/364SOm/iPV+wW5HvwPDmRJBan5vs66pTT2GtkZsZD1L+BxN4s8ycM4BWO1xyjgTI7mKjSatSnBqeJ0Cm0bIHq8hsbM9lH8yc0VsJ\"}";
+export declare const KEYCARD_BOX_B = "{\"iv\":\"QZw8ZmHqaBqQh6X6PSCcMg==\",\"v\":1,\"iter\":10000,\"ks\":256,\"ts\":64,\"mode\":\"ccm\",\"adata\":\"\",\"cipher\":\"aes\",\"salt\":\"yM+BoSyVwaY=\",\"ct\":\"oPtcvWYf287IRi9To/UobTLrm5m+YCs6Tp1CuYvPJ5oazTcbmzZkS+gn2hxAGCvojGGV61qieEgrKEKDdKLE4/jSWUhY/VXyFE6BRb2uB5pFny8NwSsVb5Gw5R38bgs0XZ0aL4RCEQgByIkWGKJn3ZbpfmzFcD+x226WZkL0gS1DN5RK8bwAfgrabVp6MupLa/NN7M/YiH9aO9PELdvu/mbyC0zdAwwY8MHpMdf5IPOJi3ieMorUtEsuzfP4SBI2EAHdFi3/VmzIKG69sZS1uIULHB5Xya5ury7+qp6nihlxJOB4S8zpri/rXow+0EQL2bKUSkQz6r6GTL5MclyfkxVcCptVMPrCcsDdVc9P0sR36iP/AsdCTJGuHbzv0AERs776+cUyqivlQj1CQ3GkIHNQKyYjktKLx1PmEMTo29hEEbKVavM8ZoxTbjL/uIaxpz9Di1zh3RB8f1HXmq2JD2XEAPAky+Ukh8FSavROG64GRkPJY4AtUxXvvzUc2M9QCy6wbDIC8prJEio5jWyKZSZ4KVpMSEK98/htMjgB8hH07CdfiJnvMVy7xe9hHOtl3zThMP6r+9g8WpGdT02Y2kWWOVZlhBaPohuiCiJLHOigiN86Tt7i5kgSTB6w8zT4tcZWzSeOBh68eAupDt0qOdfadNESQICJ3fAgfQfeR7pPzjt54npB7c9KpLnJgDhrl4LpwicwZwuYKv0gJ7t9KKKTLFHRp5RD5Nr+8tk10aIxDQxLWCVSwalie5HhTzPsF8OUqNrJJ9mSBGtsTh/Saf5osvE/ETYdU7PTJpVHDYCS5/DaCrV7acZn1ZBzCD9P9FzttzF8RlwPOideEsYDWLORvwdmNHYgTavNnOY4UnISgA07UtFsgzgJ4gC4ubCE32C5MNkX4hGIi/15O4Y0ZaiAeOu2Qnm9r6zfdYZP4TCeQAZEGKy5DsO+VYOLImvhRZD8aOoFvxmQJWM5MEMozEImms8cwJuDRP60WhZqUCgemmmyHHDRPG3+EmUGU2W4QWDQt7G6uADcDCFsYojyshg0+6QRMdc5pLR3wUa4MRug7t49kit0Q/yFMn8kHn6/jhokRdIHt8Yvo1/wnGmw7aGvKX3rtUKOpqZ4AkOakhKuqRJyJvh3nsfz6BXtjx0UnW80Dt8WgAol+x0IFLcbcnwjICotU9uupfn+ONGK0C4NUSiJVg==\"}";
+/** Prefix of the decrypted plaintext for structural sanity checking. Both boxes are MPC uShare JSON. */
+export declare const KEYCARD_PLAINTEXT_PREFIX = "{\"uShare\":{\"i\":";
+/** Expected plaintext lengths, verified against sjcl.decrypt during test authoring. */
+export declare const KEYCARD_BOX_A_LENGTH = 895;
+export declare const KEYCARD_BOX_B_LENGTH = 893;
+//# sourceMappingURL=keycard.d.ts.map

package/dist/test/unit/fixtures/keycard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"keycard.d.ts","sourceRoot":"","sources":["../../../../test/unit/fixtures/keycard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,eAAO,MAAM,gBAAgB,qCAAqC,CAAC;AAEnE,eAAO,MAAM,aAAa,m2CACwyC,CAAC;AAEn0C,eAAO,MAAM,aAAa,m2CACwyC,CAAC;AAEn0C,wGAAwG;AACxG,eAAO,MAAM,wBAAwB,wBAAoB,CAAC;AAE1D,uFAAuF;AACvF,eAAO,MAAM,oBAAoB,MAAM,CAAC;AACxC,eAAO,MAAM,oBAAoB,MAAM,CAAC"}

package/dist/test/unit/fixtures/keycard.js

@@ -0,0 +1,28 @@
+"use strict";
+/**
+ * Fixtures for real-world v1 decrypt parity tests.
+ *
+ * These come from a purpose-built BitGo test keycard (wallet name: "sol")
+ * created 2026-08-14 solely for this test suite. The wallet is a throwaway
+ * testnet Solana wallet with no real funds; the ciphertexts, wallet, and
+ * password below are safe to check in.
+ *
+ * Boxes A + B are the user and backup MPC key shares (uShare), encrypted
+ * client-side with the wallet password using the exact envelope shape BitGo
+ * produces in production (`iter=10000, ks=256, ts=64, mode=ccm, cipher=aes,
+ * adata=""`).
+ *
+ * Purpose: catch any regression where the native/shim decrypt paths diverge
+ * from SJCL on real production-shaped envelopes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEYCARD_BOX_B_LENGTH = exports.KEYCARD_BOX_A_LENGTH = exports.KEYCARD_PLAINTEXT_PREFIX = exports.KEYCARD_BOX_B = exports.KEYCARD_BOX_A = exports.KEYCARD_PASSWORD = void 0;
+exports.KEYCARD_PASSWORD = '97IoV9Qs3fuhBKYCg6ju0y6LPBHTywBY';
+exports.KEYCARD_BOX_A = '{"iv":"iury+nZhVfoWjpzbzrN1Yw==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"WiUMqHlpxiQ=","ct":"Qx6nr/Q+oEaHmmsIq75cHcR4hR4XzowpJvdgNuzcGD6v113dimT8tg2FAWAGj+syRfH19X5cDBhFX6k3ifWMbyQHneHs0OGh86kjm/v4ddNHaGgGEzhsQCWX2tAOyhxT+oG5PewnSr+xFGZePvo0GFakmPFLzF9gfvG8K3o30i0iU5UyzPdp5iAZGbZTseqp6d3KXcleA712Gnv5eT0mlDYJwoi9Io7TwCjdaa2M5r1PFkN8ZaC1aIzba3A+f7b7PDrfFckGGDIl6o2ytjNEpCKvvbfiTbk9/WOIXtMibW1e3ysmuPl5tiw2lSAtYXHQOl9rqwEvtoIMtM2uZqAE+ELf8UiabdBpdCYFiSVBgD+jjEfgUocd7xCRh2bW/Uqhu8ye7SDdZowMaTI3d/sGW8QubquPaHWQZTkhvDXttT0l1YXsIld3L2mQfDw+FpFD+SihNDiCf4fVYHFI/I9bYMx03QnUV+wXyo0dl1QXnkyVxTVOeaoJ7dM7Tp7h5cY2m5Dlp2YvAY2twRzOSPKjYu8M+rUuY0GsbodZW8mKXCLVfTyNmonSgqmLZ7V8MlZ4oR2gGfPn39XrGG9fRPj3lKb4gaFCSweHWfXAAXLN+MP9BquE57cphKn8RcuwwGPnH0j/tKOdcqKtn1XcAKtf8+s3L7utIXS+dijADqTLrjfG/2gKe4NbpykiW/vOPQ+2BbZO7d0F0YMnd2di/KD2VL5Y3M6Iib1zZAQX1r41X9Zb1/ShEsKtFyObi2zG0atYrQ6g4+f11nBbwJa6BD6n3P+UAaHvIJoXEFnaccvq3OWowlHQppQUOqCkdg5kwf2fXJqkR9hGGSBpXM48gm61hgwR12n2rDQxks6wwtdtm5BMKZrJy25x/ZAqYaQejm+0dT9SVa0qpNNOa1IdDzrPnI0AL1aLNGOVQ9EwEt9OOYoS/DBTp7JmVwhShDC5w8Br3KOKsm5qlWz/uslhfWBR7l6+BFft2jjfeCmfjZORCuhV5tX5nnQXuc13HjQkrdzaJE+LXZYtal+U83i2SfdwZnWuplTQqxKk+C0ikfGGJd7PDNb+8VEoR3rEIXk4YKJyI/HyPAVwNJN48tm/364SOm/iPV+wW5HvwPDmRJBan5vs66pTT2GtkZsZD1L+BxN4s8ycM4BWO1xyjgTI7mKjSatSnBqeJ0Cm0bIHq8hsbM9lH8yc0VsJ"}';
+exports.KEYCARD_BOX_B = '{"iv":"QZw8ZmHqaBqQh6X6PSCcMg==","v":1,"iter":10000,"ks":256,"ts":64,"mode":"ccm","adata":"","cipher":"aes","salt":"yM+BoSyVwaY=","ct":"oPtcvWYf287IRi9To/UobTLrm5m+YCs6Tp1CuYvPJ5oazTcbmzZkS+gn2hxAGCvojGGV61qieEgrKEKDdKLE4/jSWUhY/VXyFE6BRb2uB5pFny8NwSsVb5Gw5R38bgs0XZ0aL4RCEQgByIkWGKJn3ZbpfmzFcD+x226WZkL0gS1DN5RK8bwAfgrabVp6MupLa/NN7M/YiH9aO9PELdvu/mbyC0zdAwwY8MHpMdf5IPOJi3ieMorUtEsuzfP4SBI2EAHdFi3/VmzIKG69sZS1uIULHB5Xya5ury7+qp6nihlxJOB4S8zpri/rXow+0EQL2bKUSkQz6r6GTL5MclyfkxVcCptVMPrCcsDdVc9P0sR36iP/AsdCTJGuHbzv0AERs776+cUyqivlQj1CQ3GkIHNQKyYjktKLx1PmEMTo29hEEbKVavM8ZoxTbjL/uIaxpz9Di1zh3RB8f1HXmq2JD2XEAPAky+Ukh8FSavROG64GRkPJY4AtUxXvvzUc2M9QCy6wbDIC8prJEio5jWyKZSZ4KVpMSEK98/htMjgB8hH07CdfiJnvMVy7xe9hHOtl3zThMP6r+9g8WpGdT02Y2kWWOVZlhBaPohuiCiJLHOigiN86Tt7i5kgSTB6w8zT4tcZWzSeOBh68eAupDt0qOdfadNESQICJ3fAgfQfeR7pPzjt54npB7c9KpLnJgDhrl4LpwicwZwuYKv0gJ7t9KKKTLFHRp5RD5Nr+8tk10aIxDQxLWCVSwalie5HhTzPsF8OUqNrJJ9mSBGtsTh/Saf5osvE/ETYdU7PTJpVHDYCS5/DaCrV7acZn1ZBzCD9P9FzttzF8RlwPOideEsYDWLORvwdmNHYgTavNnOY4UnISgA07UtFsgzgJ4gC4ubCE32C5MNkX4hGIi/15O4Y0ZaiAeOu2Qnm9r6zfdYZP4TCeQAZEGKy5DsO+VYOLImvhRZD8aOoFvxmQJWM5MEMozEImms8cwJuDRP60WhZqUCgemmmyHHDRPG3+EmUGU2W4QWDQt7G6uADcDCFsYojyshg0+6QRMdc5pLR3wUa4MRug7t49kit0Q/yFMn8kHn6/jhokRdIHt8Yvo1/wnGmw7aGvKX3rtUKOpqZ4AkOakhKuqRJyJvh3nsfz6BXtjx0UnW80Dt8WgAol+x0IFLcbcnwjICotU9uupfn+ONGK0C4NUSiJVg=="}';
+/** Prefix of the decrypted plaintext for structural sanity checking. Both boxes are MPC uShare JSON. */
+exports.KEYCARD_PLAINTEXT_PREFIX = '{"uShare":{"i":';
+/** Expected plaintext lengths, verified against sjcl.decrypt during test authoring. */
+exports.KEYCARD_BOX_A_LENGTH = 895;
+exports.KEYCARD_BOX_B_LENGTH = 893;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoia2V5Y2FyZC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Rlc3QvdW5pdC9maXh0dXJlcy9rZXljYXJkLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQTs7Ozs7Ozs7Ozs7Ozs7O0dBZUc7OztBQUVVLFFBQUEsZ0JBQWdCLEdBQUcsa0NBQWtDLENBQUM7QUFFdEQsUUFBQSxhQUFhLEdBQ3hCLGcwQ0FBZzBDLENBQUM7QUFFdHpDLFFBQUEsYUFBYSxHQUN4QixnMENBQWcwQyxDQUFDO0FBRW4wQyx3R0FBd0c7QUFDM0YsUUFBQSx3QkFBd0IsR0FBRyxpQkFBaUIsQ0FBQztBQUUxRCx1RkFBdUY7QUFDMUUsUUFBQSxvQkFBb0IsR0FBRyxHQUFHLENBQUM7QUFDM0IsUUFBQSxvQkFBb0IsR0FBRyxHQUFHLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcbiAqIEZpeHR1cmVzIGZvciByZWFsLXdvcmxkIHYxIGRlY3J5cHQgcGFyaXR5IHRlc3RzLlxuICpcbiAqIFRoZXNlIGNvbWUgZnJvbSBhIHB1cnBvc2UtYnVpbHQgQml0R28gdGVzdCBrZXljYXJkICh3YWxsZXQgbmFtZTogXCJzb2xcIilcbiAqIGNyZWF0ZWQgMjAyNi0wOC0xNCBzb2xlbHkgZm9yIHRoaXMgdGVzdCBzdWl0ZS4gVGhlIHdhbGxldCBpcyBhIHRocm93YXdheVxuICogdGVzdG5ldCBTb2xhbmEgd2FsbGV0IHdpdGggbm8gcmVhbCBmdW5kczsgdGhlIGNpcGhlcnRleHRzLCB3YWxsZXQsIGFuZFxuICogcGFzc3dvcmQgYmVsb3cgYXJlIHNhZmUgdG8gY2hlY2sgaW4uXG4gKlxuICogQm94ZXMgQSArIEIgYXJlIHRoZSB1c2VyIGFuZCBiYWNrdXAgTVBDIGtleSBzaGFyZXMgKHVTaGFyZSksIGVuY3J5cHRlZFxuICogY2xpZW50LXNpZGUgd2l0aCB0aGUgd2FsbGV0IHBhc3N3b3JkIHVzaW5nIHRoZSBleGFjdCBlbnZlbG9wZSBzaGFwZSBCaXRHb1xuICogcHJvZHVjZXMgaW4gcHJvZHVjdGlvbiAoYGl0ZXI9MTAwMDAsIGtzPTI1NiwgdHM9NjQsIG1vZGU9Y2NtLCBjaXBoZXI9YWVzLFxuICogYWRhdGE9XCJcImApLlxuICpcbiAqIFB1cnBvc2U6IGNhdGNoIGFueSByZWdyZXNzaW9uIHdoZXJlIHRoZSBuYXRpdmUvc2hpbSBkZWNyeXB0IHBhdGhzIGRpdmVyZ2VcbiAqIGZyb20gU0pDTCBvbiByZWFsIHByb2R1Y3Rpb24tc2hhcGVkIGVudmVsb3Blcy5cbiAqL1xuXG5leHBvcnQgY29uc3QgS0VZQ0FSRF9QQVNTV09SRCA9ICc5N0lvVjlRczNmdWhCS1lDZzZqdTB5NkxQQkhUeXdCWSc7XG5cbmV4cG9ydCBjb25zdCBLRVlDQVJEX0JPWF9BID1cbiAgJ3tcIml2XCI6XCJpdXJ5K25aaFZmb1dqcHpienJOMVl3PT1cIixcInZcIjoxLFwiaXRlclwiOjEwMDAwLFwia3NcIjoyNTYsXCJ0c1wiOjY0LFwibW9kZVwiOlwiY2NtXCIsXCJhZGF0YVwiOlwiXCIsXCJjaXBoZXJcIjpcImFlc1wiLFwic2FsdFwiOlwiV2lVTXFIbHB4aVE9XCIsXCJjdFwiOlwiUXg2bnIvUStvRWFIbW1zSXE3NWNIY1I0aFI0WHpvd3BKdmRnTnV6Y0dENnYxMTNkaW1UOHRnMkZBV0FHaitzeVJmSDE5WDVjREJoRlg2azNpZldNYnlRSG5lSHMwT0doODZram0vdjRkZE5IYUdnR0V6aHNRQ1dYMnRBT3loeFQrb0c1UGV3blNyK3hGR1plUHZvMEdGYWttUEZMekY5Z2Z2RzhLM28zMGkwaVU1VXl6UGRwNWlBWkdiWlRzZXFwNmQzS1hjbGVBNzEyR252NWVUMG1sRFlKd29pOUlvN1R3Q2pkYWEyTTVyMVBGa044WmFDMWFJemJhM0ErZjdiN1BEcmZGY2tHR0RJbDZvMnl0ak5FcENLdnZiZmlUYms5L1dPSVh0TWliVzFlM3lzbXVQbDV0aXcybFNBdFlYSFFPbDlycXdFdnRvSU10TTJ1WnFBRStFTGY4VWlhYmRCcGRDWUZpU1ZCZ0QrampFZmdVb2NkN3hDUmgyYlcvVXFodTh5ZTdTRGRab3dNYVRJM2Qvc0dXOFF1YnF1UGFIV1FaVGtodkRYdHRUMGwxWVhzSWxkM0wybVFmRHcrRnBGRCtTaWhORGlDZjRmVllIRkkvSTliWU14MDNRblVWK3dYeW8wZGwxUVhua3lWeFRWT2Vhb0o3ZE03VHA3aDVjWTJtNURscDJZdkFZMnR3UnpPU1BLall1OE0rclV1WTBHc2JvZFpXOG1LWENMVmZUeU5tb25TZ3FtTFo3VjhNbFo0b1IyZ0dmUG4zOVhyR0c5ZlJQajNsS2I0Z2FGQ1N3ZUhXZlhBQVhMTitNUDlCcXVFNTdjcGhLbjhSY3V3d0dQbkgwai90S09kY3FLdG4xWGNBS3RmOCtzM0w3dXRJWFMrZGlqQURxVExyamZHLzJnS2U0TmJweWtpVy92T1BRKzJCYlpPN2QwRjBZTW5kMmRpL0tEMlZMNVkzTTZJaWIxelpBUVgxcjQxWDlaYjEvU2hFc0t0RnlPYmkyekcwYXRZclE2ZzQrZjExbkJid0phNkJENm4zUCtVQWFIdklKb1hFRm5hY2N2cTNPV293bEhRcHBRVU9xQ2tkZzVrd2YyZlhKcWtSOWhHR1NCcFhNNDhnbTYxaGd3UjEybjJyRFF4a3M2d3d0ZHRtNUJNS1pySnkyNXgvWkFxWWFRZWptKzBkVDlTVmEwcXBOTk9hMUlkRHpyUG5JMEFMMWFMTkdPVlE5RXdFdDlPT1lvUy9EQlRwN0ptVndoU2hEQzV3OEJyM0tPS3NtNXFsV3ovdXNsaGZXQlI3bDYrQkZmdDJqamZlQ21malpPUkN1aFY1dFg1bm5RWHVjMTNIalFrcmR6YUpFK0xYWll0YWwrVTgzaTJTZmR3Wm5XdXBsVFFxeEtrK0MwaWtmR0dKZDdQRE5iKzhWRW9SM3JFSVhrNFlLSnlJL0h5UEFWd05KTjQ4dG0vMzY0U09tL2lQVit3VzVIdndQRG1SSkJhbjV2czY2cFRUMkd0a1pzWkQxTCtCeE40czh5Y000QldPMXh5amdUSTdtS2pTYXRTbkJxZUowQ20wYklIcThoc2JNOWxIOHljMFZzSlwifSc7XG5cbmV4cG9ydCBjb25zdCBLRVlDQVJEX0JPWF9CID1cbiAgJ3tcIml2XCI6XCJRWnc4Wm1IcWFCcVFoNlg2UFNDY01nPT1cIixcInZcIjoxLFwiaXRlclwiOjEwMDAwLFwia3NcIjoyNTYsXCJ0c1wiOjY0LFwibW9kZVwiOlwiY2NtXCIsXCJhZGF0YVwiOlwiXCIsXCJjaXBoZXJcIjpcImFlc1wiLFwic2FsdFwiOlwieU0rQm9TeVZ3YVk9XCIsXCJjdFwiOlwib1B0Y3ZXWWYyODdJUmk5VG8vVW9iVExybTVtK1lDczZUcDFDdVl2UEo1b2F6VGNibXpaa1MrZ24yaHhBR0N2b2pHR1Y2MXFpZUVncktFS0RkS0xFNC9qU1dVaFkvVlh5RkU2QlJiMnVCNXBGbnk4TndTc1ZiNUd3NVIzOGJnczBYWjBhTDRSQ0VRZ0J5SWtXR0tKbjNaYnBmbXpGY0QreDIyNldaa0wwZ1MxRE41Uks4YndBZmdyYWJWcDZNdXBMYS9OTjdNL1lpSDlhTzlQRUxkdnUvbWJ5QzB6ZEF3d1k4TUhwTWRmNUlQT0ppM2llTW9yVXRFc3V6ZlA0U0JJMkVBSGRGaTMvVm16SUtHNjlzWlMxdUlVTEhCNVh5YTV1cnk3K3FwNm5paGx4Sk9CNFM4enByaS9yWG93KzBFUUwyYktVU2tRejZyNkdUTDVNY2x5Zmt4VmNDcHRWTVByQ2NzRGRWYzlQMHNSMzZpUC9Bc2RDVEpHdUhienYwQUVSczc3NitjVXlxaXZsUWoxQ1EzR2tJSE5RS3lZamt0S0x4MVBtRU1UbzI5aEVFYktWYXZNOFpveFRiakwvdUlheHB6OURpMXpoM1JCOGYxSFhtcTJKRDJYRUFQQWt5K1VraDhGU2F2Uk9HNjRHUmtQSlk0QXRVeFh2dnpVYzJNOVFDeTZ3YkRJQzhwckpFaW81ald5S1pTWjRLVnBNU0VLOTgvaHRNamdCOGhIMDdDZGZpSm52TVZ5N3hlOWhIT3RsM3pUaE1QNnIrOWc4V3BHZFQwMlkya1dXT1ZabGhCYVBvaHVpQ2lKTEhPaWdpTjg2VHQ3aTVrZ1NUQjZ3OHpUNHRjWld6U2VPQmg2OGVBdXBEdDBxT2RmYWRORVNRSUNKM2ZBZ2ZRZmVSN3BQemp0NTRucEI3YzlLcExuSmdEaHJsNExwd2ljd1p3dVlLdjBnSjd0OUtLS1RMRkhScDVSRDVOcis4dGsxMGFJeERReExXQ1ZTd2FsaWU1SGhUelBzRjhPVXFOckpKOW1TQkd0c1RoL1NhZjVvc3ZFL0VUWWRVN1BUSnBWSERZQ1M1L0RhQ3JWN2FjWm4xWkJ6Q0Q5UDlGenR0ekY4Umx3UE9pZGVFc1lEV0xPUnZ3ZG1OSFlnVGF2Tm5PWTRVbklTZ0EwN1V0RnNnemdKNGdDNHViQ0UzMkM1TU5rWDRoR0lpLzE1TzRZMFphaUFlT3UyUW5tOXI2emZkWVpQNFRDZVFBWkVHS3k1RHNPK1ZZT0xJbXZoUlpEOGFPb0Z2eG1RSldNNU1FTW96RUltbXM4Y3dKdURSUDYwV2hacVVDZ2VtbW15SEhEUlBHMytFbVVHVTJXNFFXRFF0N0c2dUFEY0RDRnNZb2p5c2hnMCs2UVJNZGM1cExSM3dVYTRNUnVnN3Q0OWtpdDBRL3lGTW44a0huNi9qaG9rUmRJSHQ4WXZvMS93bkdtdzdhR3ZLWDNydFVLT3BxWjRBa09ha2hLdXFSSnlKdmgzbnNmejZCWHRqeDBVblc4MER0OFdnQW9sK3gwSUZMY2JjbndqSUNvdFU5dXVwZm4rT05HSzBDNE5VU2lKVmc9PVwifSc7XG5cbi8qKiBQcmVmaXggb2YgdGhlIGRlY3J5cHRlZCBwbGFpbnRleHQgZm9yIHN0cnVjdHVyYWwgc2FuaXR5IGNoZWNraW5nLiBCb3RoIGJveGVzIGFyZSBNUEMgdVNoYXJlIEpTT04uICovXG5leHBvcnQgY29uc3QgS0VZQ0FSRF9QTEFJTlRFWFRfUFJFRklYID0gJ3tcInVTaGFyZVwiOntcImlcIjonO1xuXG4vKiogRXhwZWN0ZWQgcGxhaW50ZXh0IGxlbmd0aHMsIHZlcmlmaWVkIGFnYWluc3Qgc2pjbC5kZWNyeXB0IGR1cmluZyB0ZXN0IGF1dGhvcmluZy4gKi9cbmV4cG9ydCBjb25zdCBLRVlDQVJEX0JPWF9BX0xFTkdUSCA9IDg5NTtcbmV4cG9ydCBjb25zdCBLRVlDQVJEX0JPWF9CX0xFTkdUSCA9IDg5MztcbiJdfQ==