@bitgo-beta/sdk-core 8.2.1-beta.21 → 8.2.1-beta.2100

package/dist/test/unit/bitgo/recovery/initiate.js

@@ -0,0 +1,159 @@
+"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 });
+require("should");
+const sinon = __importStar(require("sinon"));
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const initiate_1 = require("../../../../src/bitgo/recovery/initiate");
+// A deterministic xprv used across all tests.
+const TEST_XPRV = 'xprv9s21ZrQH143K2fJ91S4BRsupcYrE6mmY96fcX5HkhoTrrwmwjd16Cn87cWinJjByrfpojjx7ezsJLx7TAKLT8m8hM5Kax9YcoxnBeJZ3t2k';
+const TEST_XPUB = 'xpub661MyMwAqRbcF9Nc7TbBo1rZAagiWEVPWKbDKThNG8zqjk76HAKLkaSbTn6dK2dQPfuD7xjicxCZVWvj67fP5nQ9W7QURmoMVAX8m6jZsGp';
+/**
+ * Encrypt plaintext with SJCL (legacy v1 envelope, matching `encryptionVersion: 1`).
+ */
+function sjclEncrypt(password, input) {
+    return sjcl.encrypt(password, input);
+}
+function makeMockBitGo(decryptImpl) {
+    return {
+        decrypt: sinon.stub().callsFake(async (params) => decryptImpl(params)),
+        encrypt: sinon.stub(),
+    };
+}
+describe('validateKey', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('returns a BIP32 node directly when key starts with xprv (bypasses decrypt)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: TEST_XPRV,
+            source: 'user',
+            passphrase: 'secret',
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        });
+        node.toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(0);
+    });
+    it('calls decrypt and returns BIP32 node when key is encrypted (not xprv)', async () => {
+        const passphrase = 'hunter2';
+        const encryptedKey = sjclEncrypt(passphrase, TEST_XPRV);
+        const bitgo = makeMockBitGo(({ password, input }) => {
+            if (input === encryptedKey && password === passphrase)
+                return TEST_XPRV;
+            throw new Error('unexpected decrypt call');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: encryptedKey,
+            source: 'user',
+            passphrase,
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        });
+        node.toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(1);
+    });
+    it('rejects with friendly message when decrypt fails (wrong passphrase)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('sjcl: ccm: tag does not match');
+        });
+        await (0, initiate_1.validateKey)(bitgo, {
+            key: 'notAnXprv',
+            source: 'user',
+            passphrase: 'wrong',
+            isUnsignedSweep: false,
+            isKrsRecovery: false,
+        }).should.be.rejectedWith('Failed to decrypt user key with passcode - try again!');
+    });
+    it('skips decrypt for unsigned sweep (isUnsignedSweep = true)', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const node = await (0, initiate_1.validateKey)(bitgo, {
+            key: TEST_XPUB,
+            source: 'user',
+            passphrase: 'secret',
+            isUnsignedSweep: true,
+            isKrsRecovery: false,
+        });
+        node.neutered().toBase58().should.equal(TEST_XPUB);
+        bitgo.decrypt.callCount.should.equal(0);
+    });
+});
+describe('getBip32Keys', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('returns [userKey, backupKey] when both are provided as xprv', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' }, { requireBitGoXpub: false });
+        keys.should.have.length(2);
+        keys[0].toBase58().should.equal(TEST_XPRV);
+        keys[1].toBase58().should.equal(TEST_XPRV);
+    });
+    it('returns three keys when requireBitGoXpub is true and bitgoKey is valid', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, bitgoKey: TEST_XPUB, recoveryDestination: 'addr' }, { requireBitGoXpub: true });
+        keys.should.have.length(3);
+        keys[2].neutered().toBase58().should.equal(TEST_XPUB);
+    });
+    it('calls decrypt for encrypted user key', async () => {
+        const passphrase = 'pass1';
+        const encryptedUserKey = sjclEncrypt(passphrase, TEST_XPRV);
+        const bitgo = makeMockBitGo(({ password, input }) => {
+            if (input === encryptedUserKey && password === passphrase)
+                return TEST_XPRV;
+            throw new Error('unexpected decrypt call');
+        });
+        const keys = await (0, initiate_1.getBip32Keys)(bitgo, { userKey: encryptedUserKey, backupKey: TEST_XPRV, walletPassphrase: passphrase, recoveryDestination: 'addr' }, { requireBitGoXpub: false });
+        keys.should.have.length(2);
+        keys[0].toBase58().should.equal(TEST_XPRV);
+        bitgo.decrypt.callCount.should.equal(1);
+    });
+    it('rejects when requireBitGoXpub is true but bitgoKey is missing', async () => {
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('should not be called');
+        });
+        await (0, initiate_1.getBip32Keys)(bitgo, { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' }, { requireBitGoXpub: true }).should.be.rejectedWith('BitGo xpub required but not provided');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"initiate.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/recovery/initiate.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport * as sinon from 'sinon';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport { validateKey, getBip32Keys } from '../../../../src/bitgo/recovery/initiate';\nimport { BitGoBase } from '../../../../src/bitgo/bitgoBase';\n\n// A deterministic xprv used across all tests.\nconst TEST_XPRV =\n  'xprv9s21ZrQH143K2fJ91S4BRsupcYrE6mmY96fcX5HkhoTrrwmwjd16Cn87cWinJjByrfpojjx7ezsJLx7TAKLT8m8hM5Kax9YcoxnBeJZ3t2k';\nconst TEST_XPUB =\n  'xpub661MyMwAqRbcF9Nc7TbBo1rZAagiWEVPWKbDKThNG8zqjk76HAKLkaSbTn6dK2dQPfuD7xjicxCZVWvj67fP5nQ9W7QURmoMVAX8m6jZsGp';\n\n/**\n * Encrypt plaintext with SJCL (legacy v1 envelope, matching `encryptionVersion: 1`).\n */\nfunction sjclEncrypt(password: string, input: string): string {\n  return sjcl.encrypt(password, input) as unknown as string;\n}\n\nfunction makeMockBitGo(decryptImpl: (params: { password?: string; input: string }) => string): BitGoBase {\n  return {\n    decrypt: sinon.stub().callsFake(async (params: { password?: string; input: string }) => decryptImpl(params)),\n    encrypt: sinon.stub(),\n  } as unknown as BitGoBase;\n}\n\ndescribe('validateKey', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('returns a BIP32 node directly when key starts with xprv (bypasses decrypt)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const node = await validateKey(bitgo, {\n      key: TEST_XPRV,\n      source: 'user',\n      passphrase: 'secret',\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    });\n    node.toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(0);\n  });\n\n  it('calls decrypt and returns BIP32 node when key is encrypted (not xprv)', async () => {\n    const passphrase = 'hunter2';\n    const encryptedKey = sjclEncrypt(passphrase, TEST_XPRV);\n    const bitgo = makeMockBitGo(({ password, input }) => {\n      if (input === encryptedKey && password === passphrase) return TEST_XPRV;\n      throw new Error('unexpected decrypt call');\n    });\n    const node = await validateKey(bitgo, {\n      key: encryptedKey,\n      source: 'user',\n      passphrase,\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    });\n    node.toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(1);\n  });\n\n  it('rejects with friendly message when decrypt fails (wrong passphrase)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('sjcl: ccm: tag does not match');\n    });\n    await validateKey(bitgo, {\n      key: 'notAnXprv',\n      source: 'user',\n      passphrase: 'wrong',\n      isUnsignedSweep: false,\n      isKrsRecovery: false,\n    }).should.be.rejectedWith('Failed to decrypt user key with passcode - try again!');\n  });\n\n  it('skips decrypt for unsigned sweep (isUnsignedSweep = true)', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const node = await validateKey(bitgo, {\n      key: TEST_XPUB,\n      source: 'user',\n      passphrase: 'secret',\n      isUnsignedSweep: true,\n      isKrsRecovery: false,\n    });\n    node.neutered().toBase58().should.equal(TEST_XPUB);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(0);\n  });\n});\n\ndescribe('getBip32Keys', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('returns [userKey, backupKey] when both are provided as xprv', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' },\n      { requireBitGoXpub: false }\n    );\n    keys.should.have.length(2);\n    keys[0].toBase58().should.equal(TEST_XPRV);\n    keys[1].toBase58().should.equal(TEST_XPRV);\n  });\n\n  it('returns three keys when requireBitGoXpub is true and bitgoKey is valid', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, bitgoKey: TEST_XPUB, recoveryDestination: 'addr' },\n      { requireBitGoXpub: true }\n    );\n    keys.should.have.length(3);\n    keys[2].neutered().toBase58().should.equal(TEST_XPUB);\n  });\n\n  it('calls decrypt for encrypted user key', async () => {\n    const passphrase = 'pass1';\n    const encryptedUserKey = sjclEncrypt(passphrase, TEST_XPRV);\n    const bitgo = makeMockBitGo(({ password, input }) => {\n      if (input === encryptedUserKey && password === passphrase) return TEST_XPRV;\n      throw new Error('unexpected decrypt call');\n    });\n    const keys = await getBip32Keys(\n      bitgo,\n      { userKey: encryptedUserKey, backupKey: TEST_XPRV, walletPassphrase: passphrase, recoveryDestination: 'addr' },\n      { requireBitGoXpub: false }\n    );\n    keys.should.have.length(2);\n    keys[0].toBase58().should.equal(TEST_XPRV);\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(1);\n  });\n\n  it('rejects when requireBitGoXpub is true but bitgoKey is missing', async () => {\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('should not be called');\n    });\n    await getBip32Keys(\n      bitgo,\n      { userKey: TEST_XPRV, backupKey: TEST_XPRV, recoveryDestination: 'addr' },\n      { requireBitGoXpub: true }\n    ).should.be.rejectedWith('BitGo xpub required but not provided');\n  });\n});\n"]}

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=derivableEd25519Pub.d.ts.map

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"derivableEd25519Pub.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/derivableEd25519Pub.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,CAAC"}

package/dist/test/unit/bitgo/safe/derivableEd25519Pub.js

@@ -0,0 +1,133 @@
+"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 });
+require("should");
+const src_1 = require("../../../../src");
+// Cross-repo fixture: byte-identical to wallet-platform
+// test/unit/base/safes/fixtures/derivableEd25519Pub.json. Four independent implementations of this
+// format will otherwise drift, and the failure mode is unrecoverable wallets.
+const fixture = __importStar(require("./fixtures/derivableEd25519Pub.json"));
+const PUBLIC_KEY = Buffer.alloc(32);
+const CHAIN_CODE = Buffer.alloc(32, 0xab);
+const ROOT_PUB = (0, src_1.encodeDerivableEd25519Pub)(PUBLIC_KEY, CHAIN_CODE);
+const ROOT_KEYCHAIN = Buffer.concat([PUBLIC_KEY, CHAIN_CODE]).toString('hex');
+const STRKEY_PUBLIC = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';
+const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';
+describe('derivableEd25519Pub', function () {
+    describe('base32 root format', function () {
+        it('encodes 32-byte public key plus 32-byte chain code', function () {
+            src_1.DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(32);
+            src_1.DERIVABLE_ED25519_PUB_LENGTH.should.equal(103);
+            ROOT_PUB.should.match(/^[A-Z2-7]{103}$/);
+            (0, src_1.decodeDerivableEd25519Pub)(ROOT_PUB).pub.equals(PUBLIC_KEY).should.equal(true);
+            (0, src_1.decodeDerivableEd25519Pub)(ROOT_PUB).chainCode.equals(CHAIN_CODE).should.equal(true);
+        });
+        it('matches the constants pinned in the shared fixture', function () {
+            src_1.DERIVABLE_ED25519_PUB_LENGTH.should.equal(fixture.rootPubBase32Length);
+            src_1.DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(fixture.chainCodeBytes);
+        });
+        it('generates raw chain code for root composition', function () {
+            (0, src_1.generateEd25519ChainCode)().length.should.equal(32);
+        });
+    });
+    describe('fixture vectors', function () {
+        for (const vector of fixture.valid) {
+            it(`round-trips ${vector.name}`, function () {
+                const composite = (0, src_1.encodeDerivableEd25519Pub)(Buffer.from(vector.pub, 'hex'), Buffer.from(vector.chainCode, 'hex'));
+                composite.should.equal(vector.composite);
+                const decoded = (0, src_1.decodeDerivableEd25519Pub)(vector.composite);
+                decoded.pub.toString('hex').should.equal(vector.pub);
+                decoded.chainCode.toString('hex').should.equal(vector.chainCode);
+                (0, src_1.isDerivableEd25519Pub)(vector.composite).should.equal(true);
+            });
+        }
+        for (const vector of fixture.invalidComposite) {
+            it(`rejects ${vector.name}`, function () {
+                (0, src_1.isDerivableEd25519Pub)(vector.composite).should.equal(false);
+                (() => (0, src_1.decodeDerivableEd25519Pub)(vector.composite)).should.throw(/Invalid derivable ed25519 pub/);
+            });
+        }
+    });
+    describe('raw public soft derivation', function () {
+        it('derives a deterministic public key and discards the child chain code', async function () {
+            const eddsa = await src_1.Eddsa.initialize(await src_1.Ed25519BIP32.initialize());
+            const derived = eddsa.deriveUnhardened(ROOT_KEYCHAIN, 'm/7');
+            derived.length.should.equal(128);
+            derived.slice(0, 64).should.match(/^[0-9a-f]{64}$/);
+            derived.slice(64).should.match(/^[0-9a-f]{64}$/);
+            (await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 7)).toString('hex').should.equal(derived.slice(0, 64));
+        });
+        // The golden vectors below pin the unhardened derivation output shared cross-repo with
+        // wallet-platform: a divergent implementation derives co-signer keys nobody else can
+        // reproduce, permanently bricking the wallets minted with it.
+        for (const vector of fixture.softDerivation) {
+            it(`derives the pinned golden child: ${vector.name}`, async function () {
+                const child = await (0, src_1.softDeriveChildPubEd25519)(vector.composite, vector.index);
+                child.toString('hex').should.equal(vector.childPub);
+            });
+        }
+        it('rejects a hardened or out-of-range index', async function () {
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, -1).should.be.rejectedWith(/non-hardened/);
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 0x80000000).should.be.rejectedWith(/non-hardened/);
+            await (0, src_1.softDeriveChildPubEd25519)(ROOT_PUB, 1.5).should.be.rejectedWith(/non-hardened/);
+        });
+        it('rejects a malformed root', async function () {
+            await (0, src_1.softDeriveChildPubEd25519)(fixture.invalidComposite[1].composite, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);
+            await (0, src_1.softDeriveChildPubEd25519)(STRKEY_PUBLIC, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);
+        });
+    });
+    describe('Stellar user-key codecs', function () {
+        it('keeps Stellar encoding separate from the neutral root format', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)(STRKEY_PUBLIC).should.equal(true);
+            (0, src_1.encodeEd25519StrKeyPublicKey)((0, src_1.decodeEd25519StrKeyPublicKey)(STRKEY_PUBLIC)).should.equal(STRKEY_PUBLIC);
+            (0, src_1.decodeEd25519StrKeySecretSeed)(STRKEY_SEED).length.should.equal(32);
+            (0, src_1.isDerivableEd25519Pub)(STRKEY_PUBLIC).should.equal(false);
+            (0, src_1.isChecksumValidStrKeyEd25519Pub)(STRKEY_PUBLIC).should.equal(true);
+        });
+        it('rejects a public key with a corrupted checksum', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYA').should.equal(false);
+        });
+        it('rejects a secret seed where a public key is required', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH').should.equal(false);
+            (() => (0, src_1.decodeEd25519StrKeyPublicKey)('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH')).should.throw(/StrKey public key/);
+        });
+        it('rejects a non-base32 character, the empty string, and lowercase', function () {
+            (0, src_1.isValidEd25519StrKeyPublicKey)('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKY1').should.equal(false);
+            (0, src_1.isValidEd25519StrKeyPublicKey)('').should.equal(false);
+            (0, src_1.isValidEd25519StrKeyPublicKey)(STRKEY_PUBLIC.toLowerCase()).should.equal(false);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"derivableEd25519Pub.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/derivableEd25519Pub.ts"],"names":[],"mappings":"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","sourcesContent":["import 'should';\nimport {\n  DERIVABLE_ED25519_CHAIN_CODE_BYTES,\n  DERIVABLE_ED25519_PUB_LENGTH,\n  Ed25519BIP32,\n  Eddsa,\n  decodeDerivableEd25519Pub,\n  decodeEd25519StrKeyPublicKey,\n  decodeEd25519StrKeySecretSeed,\n  encodeDerivableEd25519Pub,\n  encodeEd25519StrKeyPublicKey,\n  generateEd25519ChainCode,\n  isChecksumValidStrKeyEd25519Pub,\n  isDerivableEd25519Pub,\n  isValidEd25519StrKeyPublicKey,\n  softDeriveChildPubEd25519,\n} from '../../../../src';\n\n// Cross-repo fixture: byte-identical to wallet-platform\n// test/unit/base/safes/fixtures/derivableEd25519Pub.json. Four independent implementations of this\n// format will otherwise drift, and the failure mode is unrecoverable wallets.\nimport * as fixture from './fixtures/derivableEd25519Pub.json';\n\nconst PUBLIC_KEY = Buffer.alloc(32);\nconst CHAIN_CODE = Buffer.alloc(32, 0xab);\nconst ROOT_PUB = encodeDerivableEd25519Pub(PUBLIC_KEY, CHAIN_CODE);\nconst ROOT_KEYCHAIN = Buffer.concat([PUBLIC_KEY, CHAIN_CODE]).toString('hex');\nconst STRKEY_PUBLIC = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';\nconst STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';\n\ndescribe('derivableEd25519Pub', function () {\n  describe('base32 root format', function () {\n    it('encodes 32-byte public key plus 32-byte chain code', function () {\n      DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(32);\n      DERIVABLE_ED25519_PUB_LENGTH.should.equal(103);\n      ROOT_PUB.should.match(/^[A-Z2-7]{103}$/);\n      decodeDerivableEd25519Pub(ROOT_PUB).pub.equals(PUBLIC_KEY).should.equal(true);\n      decodeDerivableEd25519Pub(ROOT_PUB).chainCode.equals(CHAIN_CODE).should.equal(true);\n    });\n\n    it('matches the constants pinned in the shared fixture', function () {\n      DERIVABLE_ED25519_PUB_LENGTH.should.equal(fixture.rootPubBase32Length);\n      DERIVABLE_ED25519_CHAIN_CODE_BYTES.should.equal(fixture.chainCodeBytes);\n    });\n\n    it('generates raw chain code for root composition', function () {\n      generateEd25519ChainCode().length.should.equal(32);\n    });\n  });\n\n  describe('fixture vectors', function () {\n    for (const vector of fixture.valid) {\n      it(`round-trips ${vector.name}`, function () {\n        const composite = encodeDerivableEd25519Pub(\n          Buffer.from(vector.pub, 'hex'),\n          Buffer.from(vector.chainCode, 'hex')\n        );\n        composite.should.equal(vector.composite);\n        const decoded = decodeDerivableEd25519Pub(vector.composite);\n        decoded.pub.toString('hex').should.equal(vector.pub);\n        decoded.chainCode.toString('hex').should.equal(vector.chainCode);\n        isDerivableEd25519Pub(vector.composite).should.equal(true);\n      });\n    }\n\n    for (const vector of fixture.invalidComposite) {\n      it(`rejects ${vector.name}`, function () {\n        isDerivableEd25519Pub(vector.composite).should.equal(false);\n        (() => decodeDerivableEd25519Pub(vector.composite)).should.throw(/Invalid derivable ed25519 pub/);\n      });\n    }\n  });\n\n  describe('raw public soft derivation', function () {\n    it('derives a deterministic public key and discards the child chain code', async function () {\n      const eddsa = await Eddsa.initialize(await Ed25519BIP32.initialize());\n      const derived = eddsa.deriveUnhardened(ROOT_KEYCHAIN, 'm/7');\n      derived.length.should.equal(128);\n      derived.slice(0, 64).should.match(/^[0-9a-f]{64}$/);\n      derived.slice(64).should.match(/^[0-9a-f]{64}$/);\n      (await softDeriveChildPubEd25519(ROOT_PUB, 7)).toString('hex').should.equal(derived.slice(0, 64));\n    });\n\n    // The golden vectors below pin the unhardened derivation output shared cross-repo with\n    // wallet-platform: a divergent implementation derives co-signer keys nobody else can\n    // reproduce, permanently bricking the wallets minted with it.\n    for (const vector of fixture.softDerivation) {\n      it(`derives the pinned golden child: ${vector.name}`, async function () {\n        const child = await softDeriveChildPubEd25519(vector.composite, vector.index);\n        child.toString('hex').should.equal(vector.childPub);\n      });\n    }\n\n    it('rejects a hardened or out-of-range index', async function () {\n      await softDeriveChildPubEd25519(ROOT_PUB, -1).should.be.rejectedWith(/non-hardened/);\n      await softDeriveChildPubEd25519(ROOT_PUB, 0x80000000).should.be.rejectedWith(/non-hardened/);\n      await softDeriveChildPubEd25519(ROOT_PUB, 1.5).should.be.rejectedWith(/non-hardened/);\n    });\n\n    it('rejects a malformed root', async function () {\n      await softDeriveChildPubEd25519(fixture.invalidComposite[1].composite, 0).should.be.rejectedWith(\n        /Invalid derivable ed25519 pub/\n      );\n      await softDeriveChildPubEd25519(STRKEY_PUBLIC, 0).should.be.rejectedWith(/Invalid derivable ed25519 pub/);\n    });\n  });\n\n  describe('Stellar user-key codecs', function () {\n    it('keeps Stellar encoding separate from the neutral root format', function () {\n      isValidEd25519StrKeyPublicKey(STRKEY_PUBLIC).should.equal(true);\n      encodeEd25519StrKeyPublicKey(decodeEd25519StrKeyPublicKey(STRKEY_PUBLIC)).should.equal(STRKEY_PUBLIC);\n      decodeEd25519StrKeySecretSeed(STRKEY_SEED).length.should.equal(32);\n      isDerivableEd25519Pub(STRKEY_PUBLIC).should.equal(false);\n      isChecksumValidStrKeyEd25519Pub(STRKEY_PUBLIC).should.equal(true);\n    });\n\n    it('rejects a public key with a corrupted checksum', function () {\n      isValidEd25519StrKeyPublicKey('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYA').should.equal(false);\n    });\n\n    it('rejects a secret seed where a public key is required', function () {\n      isValidEd25519StrKeyPublicKey('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH').should.equal(false);\n      (() => decodeEd25519StrKeyPublicKey('SA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH')).should.throw(\n        /StrKey public key/\n      );\n    });\n\n    it('rejects a non-base32 character, the empty string, and lowercase', function () {\n      isValidEd25519StrKeyPublicKey('GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKY1').should.equal(false);\n      isValidEd25519StrKeyPublicKey('').should.equal(false);\n      isValidEd25519StrKeyPublicKey(STRKEY_PUBLIC.toLowerCase()).should.equal(false);\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/safe/fixtures/derivableEd25519Pub.json

@@ -0,0 +1,72 @@
+{
+    "$comment": "Shared ed25519Multisig safe-root fixture: raw 32-byte public key || raw 32-byte chain code encoded together as canonical unpadded RFC 4648 base32 (uppercase A-Z2-7, 103 characters). Plain JSON with no repo-specific imports so wallet-platform, BitGoJS sdk-core, BitGoJS modules/key-card and WRW can all consume this identical file. The final base32 character carries 2 significant bits and 3 zero padding bits, so 8 spellings decode to the same 64 bytes and only the zero-padded one is valid — validators must re-encode, not just match the alphabet. The softDerivation vectors pin the m/<index> unhardened child public key expected from a root: they were generated with @bitgo-beta/account-lib's Eddsa.deriveUnhardened (via @bitgo-beta/sdk-core) over genuine ed25519 points, and every consuming implementation MUST reproduce them exactly — a divergent unhardened derivation derives co-signer keys nobody else can reproduce, permanently bricking the wallets minted with it. The child chain code is deliberately not pinned: consumers discard it after deriving the child public key.",
+    "publicKeyBytes": 32,
+    "chainCodeBytes": 32,
+    "rootPubBase32Length": 103,
+    "valid": [
+        {
+            "name": "zero public key and repeated chain code",
+            "pub": "0000000000000000000000000000000000000000000000000000000000000000",
+            "chainCode": "abababababababababababababababababababababababababababababababab",
+            "composite": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XKY"
+        },
+        {
+            "name": "mixed public key and chain code",
+            "pub": "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
+            "chainCode": "fedcba9876543210fedcba9876543210fedcba9876543210fedcba9876543210",
+            "composite": "AERUKZ4JVPG66AJDIVTYTK6N54ASGRLHRGV433YBENCWPCNLZXX75XF2TB3FIMQQ73OLVGDWKQZBB7W4XKMHMVBSCD7NZOUYOZKDEEA"
+        },
+        {
+            "name": "typical public key with a mixed chain code",
+            "pub": "d5a7c39b1f84e206a93f7c4b8d2e615f0a9c3b7e5d1f48c2a6b0e3947f518d26",
+            "chainCode": "3c9f1a7b5e2d84c6a0f3b9d7e1c5a2846f0b3d9e7c1a5f8b2d04e6c9a3f7b1d5",
+            "composite": "2WT4HGY7QTRANKJ7PRFY2LTBL4FJYO36LUPURQVGWDRZI72RRUTDZHY2PNPC3BGGUDZ3TV7BYWRII3YLHWPHYGS7RMWQJZWJUP33DVI"
+        },
+        {
+            "name": "typical public key with a repeating chain code",
+            "pub": "9b2f7d4a1e8c3b6f5a0d9e2c7b4f1a8d3e6c9b2f5a8d1e4c7b0f3a6d9e2c5b81",
+            "chainCode": "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+            "composite": "TMXX2SQ6RQ5W6WQNTYWHWTY2RU7GZGZPLKGR4TD3B45G3HRMLOA43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TI"
+        }
+    ],
+    "invalidComposite": [
+        {
+            "name": "lowercase",
+            "composite": "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaakxk5lvov2xk5lvov2xk5lvov2xk5lvov2xk5lvov2xk5lvov2xky"
+        },
+        {
+            "name": "short",
+            "composite": "AA"
+        },
+        {
+            "name": "non-canonical trailing bits",
+            "composite": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAKXK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XK5LVOV2XKZ"
+        }
+    ],
+    "softDerivation": [
+        {
+            "name": "root A at m/0",
+            "index": 0,
+            "pub": "07a2206d82e1238043906260d95f86e046056610756050d558d282476556d0a6",
+            "chainCode": "1111111111111111111111111111111111111111111111111111111111111111",
+            "composite": "A6RCA3MC4ERYAQ4QMJQNSX4G4BDAKZQQOVQFBVKY2KBEOZKW2CTBCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEI",
+            "childPub": "3cec3c1be67f00f8f8d5a33cc3937ba7d7da96a79332af622942f38150f32d6e"
+        },
+        {
+            "name": "root A at m/1",
+            "index": 1,
+            "pub": "07a2206d82e1238043906260d95f86e046056610756050d558d282476556d0a6",
+            "chainCode": "1111111111111111111111111111111111111111111111111111111111111111",
+            "composite": "A6RCA3MC4ERYAQ4QMJQNSX4G4BDAKZQQOVQFBVKY2KBEOZKW2CTBCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEIRCEI",
+            "childPub": "b315782a33f863e87a40731157456e62ce7d4e941cfb2e3f71c56edb993bf7af"
+        },
+        {
+            "name": "root B at max non-hardened m/2147483647",
+            "index": 2147483647,
+            "pub": "6af98980a20d1d090d729aee97e8cab65df61eeec9dc7b6070baa6b0e02f860d",
+            "chainCode": "cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd",
+            "composite": "NL4YTAFCBUOQSDLSTLXJP2GKWZO7MHXOZHOHWYDQXKTLBYBPQYG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TONZXG43TI",
+            "childPub": "acda5ebd6543ed99141eb9da0cf1101e3ce11a637ee83743786b67a3b319439e"
+        }
+    ]
+}

package/dist/test/unit/bitgo/safe/recovery.d.ts

@@ -0,0 +1,2 @@
+import 'should';
+//# sourceMappingURL=recovery.d.ts.map

package/dist/test/unit/bitgo/safe/recovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recovery.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/recovery.ts"],"names":[],"mappings":"AAAA,OAAO,QAAQ,CAAC"}