@bitgo-beta/sdk-core 8.2.1-beta.213 → 8.2.1-beta.2130

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

@@ -0,0 +1,606 @@
+"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 assert_1 = __importDefault(require("assert"));
+require("should");
+const sinon = __importStar(require("sinon"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const ed25519_1 = require("@noble/curves/ed25519");
+const sjcl = __importStar(require("@bitgo-beta/sjcl"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const keyShareEnvelope_1 = require("../../../../src/bitgo/utils/tss/keyShareEnvelope");
+const errors_1 = require("../../../../src/bitgo/errors");
+const recovery_1 = require("../../../../src/bitgo/safe/recovery");
+const src_1 = require("../../../../src");
+const eddsa_1 = require("../../../../src/bitgo/tss/eddsa/eddsa");
+const eddsaMPCv2_1 = require("../../../../src/bitgo/utils/tss/eddsa/eddsaMPCv2");
+// The ed25519 soft co-signer private halves asserted below are pinned cross-repo in the shared
+// GV1 fixture (byte-identical to wallet-platform's copy).
+const bip44Fixture = __importStar(require("./fixtures/safeBip44Vectors.json"));
+const PASSWORD = 'safe-password';
+function makeMockBitGo(decryptImpl) {
+    return {
+        decrypt: sinon.stub().callsFake(async (params) => decryptImpl(params)),
+    };
+}
+/** A fake decrypt that only recognizes the user/backup tokens; any other input (e.g. a Box C public) throws. */
+function makeDecryptMap(entries) {
+    return ({ password, input }) => {
+        password.should.equal(PASSWORD);
+        if (!(input in entries)) {
+            throw new Error(`unexpected decrypt input: ${input}`);
+        }
+        return entries[input];
+    };
+}
+function box(values) {
+    return JSON.stringify(values);
+}
+describe('decryptSafeKeycard', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    it('decrypts onchain roots to strings and returns Box C verbatim', async () => {
+        const userBox = box({
+            secp256k1Multisig: 'enc-user-secp',
+            ed25519Multisig: 'enc-user-ed25519',
+            ecdsaMpc: 'enc-user-ecdsa',
+            eddsaMpc: 'enc-user-eddsa',
+        });
+        const backupBox = box({
+            secp256k1Multisig: 'enc-backup-secp',
+            ed25519Multisig: { prv: 'enc-backup-ed25519', chainCode: 'C'.repeat(52) },
+            ecdsaMpc: 'enc-backup-ecdsa',
+            eddsaMpc: 'enc-backup-eddsa',
+        });
+        const bitgoBox = box({
+            secp256k1Multisig: 'xpub-secp-bitgo',
+            ed25519Multisig: 'pub-ed25519-bitgo',
+            ecdsaMpc: 'common-ecdsa-bitgo',
+            eddsaMpc: 'common-eddsa-bitgo',
+        });
+        const mpcUser = (0, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(Buffer.from('user-signing'), Buffer.from('user-reduced'), Buffer.from('user-vrf'));
+        const mpcBackup = (0, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(Buffer.from('backup-signing'), Buffer.from('backup-reduced'), Buffer.from('backup-vrf'));
+        const bitgo = makeMockBitGo(makeDecryptMap({
+            'enc-user-secp': 'xprv-user',
+            'enc-backup-secp': 'xprv-backup',
+            'enc-user-ed25519': 'S-user-seed',
+            'enc-backup-ed25519': 'S-backup-seed',
+            'enc-user-ecdsa': mpcUser.reducedEnvelope.toString('base64'),
+            'enc-backup-ecdsa': mpcBackup.reducedEnvelope.toString('base64'),
+            'enc-user-eddsa': mpcUser.reducedEnvelope.toString('base64'),
+            'enc-backup-eddsa': mpcBackup.reducedEnvelope.toString('base64'),
+        }));
+        const result = await (0, recovery_1.decryptSafeKeycard)({
+            bitgo,
+            userKeyBox: userBox,
+            backupKeyBox: backupBox,
+            bitgoKeyBox: bitgoBox,
+            password: PASSWORD,
+        });
+        result.secp256k1Multisig.user.should.equal('xprv-user');
+        result.secp256k1Multisig.backup.should.equal('xprv-backup');
+        result.secp256k1Multisig.bitgo.should.equal('xpub-secp-bitgo');
+        result.ed25519Multisig.user.should.equal('S-user-seed');
+        result.ed25519Multisig.backup.prv.should.equal('S-backup-seed');
+        result.ed25519Multisig.backup.chainCode.should.equal('C'.repeat(52));
+        result.ed25519Multisig.bitgo.should.equal('pub-ed25519-bitgo');
+        result.ecdsaMpc.user.signing.toString('hex').should.equal(Buffer.from('user-reduced').toString('hex'));
+        result.ecdsaMpc.user.vrf.toString('hex').should.equal(Buffer.from('user-vrf').toString('hex'));
+        result.ecdsaMpc.backup.signing.toString('hex').should.equal(Buffer.from('backup-reduced').toString('hex'));
+        result.ecdsaMpc.backup.vrf.toString('hex').should.equal(Buffer.from('backup-vrf').toString('hex'));
+        result.ecdsaMpc.bitgo.should.equal('common-ecdsa-bitgo');
+        result.eddsaMpc.bitgo.should.equal('common-eddsa-bitgo');
+        // 4 slots × (user + backup) = 8 decrypts; BitGo (Box C) is never decrypted.
+        bitgo.decrypt.callCount.should.equal(8);
+    });
+    it('decrypts the seed from an object-form ed25519Multisig backup entry', async () => {
+        const userBox = box({
+            secp256k1Multisig: 'enc-user-secp',
+            ed25519Multisig: 'enc-user-ed25519',
+            ecdsaMpc: 'enc-user-ecdsa',
+            eddsaMpc: 'enc-user-eddsa',
+        });
+        const backupBox = JSON.stringify({
+            secp256k1Multisig: 'enc-backup-secp',
+            ed25519Multisig: { prv: 'enc-backup-ed25519', chainCode: 'A'.repeat(52) },
+            ecdsaMpc: 'enc-backup-ecdsa',
+            eddsaMpc: 'enc-backup-eddsa',
+        });
+        const bitgoBox = box({
+            secp256k1Multisig: 'xpub-secp-bitgo',
+            ed25519Multisig: 'pub-ed25519-bitgo',
+            ecdsaMpc: 'common-ecdsa-bitgo',
+            eddsaMpc: 'common-eddsa-bitgo',
+        });
+        const mpcUser = (0, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(Buffer.from('user-signing'), Buffer.from('user-reduced'), Buffer.from('user-vrf'));
+        const mpcBackup = (0, keyShareEnvelope_1.buildSafeMpcKeyEnvelopes)(Buffer.from('backup-signing'), Buffer.from('backup-reduced'), Buffer.from('backup-vrf'));
+        const bitgo = makeMockBitGo(makeDecryptMap({
+            'enc-user-secp': 'xprv-user',
+            'enc-backup-secp': 'xprv-backup',
+            'enc-user-ed25519': 'S-user-seed',
+            'enc-backup-ed25519': 'S-backup-seed',
+            'enc-user-ecdsa': mpcUser.reducedEnvelope.toString('base64'),
+            'enc-backup-ecdsa': mpcBackup.reducedEnvelope.toString('base64'),
+            'enc-user-eddsa': mpcUser.reducedEnvelope.toString('base64'),
+            'enc-backup-eddsa': mpcBackup.reducedEnvelope.toString('base64'),
+        }));
+        const result = await (0, recovery_1.decryptSafeKeycard)({
+            bitgo,
+            userKeyBox: userBox,
+            backupKeyBox: backupBox,
+            bitgoKeyBox: bitgoBox,
+            password: PASSWORD,
+        });
+        result.ed25519Multisig.backup.prv.should.equal('S-backup-seed');
+        result.ed25519Multisig.backup.chainCode.should.equal('A'.repeat(52));
+    });
+    it('rejects an ed25519 chain-code entry in a non-backup slot (fail closed)', async () => {
+        const userBox = JSON.stringify({
+            secp256k1Multisig: { prv: 'enc-user-secp', chainCode: 'A'.repeat(52) },
+            ed25519Multisig: 'enc-user-ed25519',
+            ecdsaMpc: 'enc-user-ecdsa',
+            eddsaMpc: 'enc-user-eddsa',
+        });
+        await (0, recovery_1.decryptSafeKeycard)({
+            bitgo: makeMockBitGo(makeDecryptMap({})),
+            userKeyBox: userBox,
+            backupKeyBox: userBox,
+            bitgoKeyBox: userBox,
+            password: PASSWORD,
+        }).should.be.rejectedWith(/unexpected ed25519 chain-code entry/);
+    });
+    it('throws IncorrectPasswordError when decryption fails (wrong password)', async () => {
+        const userBox = box({
+            secp256k1Multisig: 'enc-user-secp',
+            ed25519Multisig: 'enc-user-ed25519',
+            ecdsaMpc: 'enc-user-ecdsa',
+            eddsaMpc: 'enc-user-eddsa',
+        });
+        const bitgo = makeMockBitGo(() => {
+            throw new Error('argon2: tag does not match');
+        });
+        await (0, recovery_1.decryptSafeKeycard)({
+            bitgo,
+            userKeyBox: userBox,
+            backupKeyBox: userBox,
+            bitgoKeyBox: userBox,
+            password: 'wrong-password',
+        }).should.be.rejectedWith(errors_1.IncorrectPasswordError);
+    });
+});
+const MPC_ROOT = { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) };
+function makeRoots(secp) {
+    return {
+        secp256k1Multisig: secp,
+        ed25519Multisig: { user: 'u', backup: { prv: 'b', chainCode: 'c' }, bitgo: 'g' },
+        ecdsaMpc: { user: MPC_ROOT, backup: MPC_ROOT, bitgo: 'g' },
+        eddsaMpc: { user: MPC_ROOT, backup: MPC_ROOT, bitgo: 'g' },
+    };
+}
+describe('deriveSafeWalletKeys', () => {
+    const userRoot = utxo_lib_1.bip32.fromSeed(Buffer.from('000102030405060708090a0b0c0d0e0f', 'hex'));
+    const backupRoot = utxo_lib_1.bip32.fromSeed(Buffer.from('1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100', 'hex'));
+    const bitgoRoot = utxo_lib_1.bip32
+        .fromSeed(Buffer.from('2f2e2d2c2b2a292827262524232221201f1e1d1c1b1a19181716151413121110', 'hex'))
+        .neutered();
+    const roots = makeRoots({
+        user: userRoot.toBase58(),
+        backup: backupRoot.toBase58(),
+        bitgo: bitgoRoot.toBase58(),
+    });
+    it('derives the BIP44 child triplet for slot 1', async () => {
+        const result = await (0, recovery_1.deriveSafeWalletKeys)({ coin: 'btc', slot: 'secp256k1Multisig', account: 0, roots });
+        if (result.slot !== 'secp256k1Multisig') {
+            throw new Error('expected secp256k1Multisig slot');
+        }
+        result.path.should.equal("m/44'/0'/1'/0'");
+        result.keys.user.prv.should.equal(userRoot.derivePath("m/44'/0'/1'/0'").toBase58());
+        result.keys.user.pub.should.equal(userRoot.derivePath("m/44'/0'/1'/0'").neutered().toBase58());
+        result.keys.backup.prv.should.equal(backupRoot.derivePath('m/44/0/1/0').toBase58());
+        result.keys.bitgo.pub.should.equal(bitgoRoot.derivePath('m/44/0/1/0').toBase58());
+    });
+    it('varies the path with the account', async () => {
+        const result = await (0, recovery_1.deriveSafeWalletKeys)({ coin: 'btc', slot: 'secp256k1Multisig', account: 2, roots });
+        result.path.should.equal("m/44'/0'/1'/2'");
+    });
+    it('derives the ecdsaMpc child via the DKLs ceremony', async () => {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.DklsUtils.generateDKGKeyShares();
+        const [vrfUser, vrfBackup] = await sdk_lib_mpc_1.DklsVrfUtils.generateVrfDKGKeyShares();
+        const mpcRoots = {
+            ...roots,
+            ecdsaMpc: {
+                user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },
+                backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },
+                bitgo: 'g',
+            },
+        };
+        const result = await (0, recovery_1.deriveSafeWalletKeys)({ coin: 'eth', slot: 'ecdsaMpc', account: 0, roots: mpcRoots });
+        if (result.slot !== 'ecdsaMpc') {
+            throw new Error('expected ecdsaMpc slot');
+        }
+        result.path.should.equal("m/44'/60'/3'/0'");
+        result.keys.commonKeychain.should.be.a.String();
+        result.keys.user.should.be.a.String();
+        result.keys.backup.should.be.a.String();
+    });
+    it('derives and signs the eddsaMpc slot-4 BIP44 child', async function () {
+        const [userDkg, backupDkg, bitgoDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+        const [vrfUser, vrfBackup, vrfBitgo] = await sdk_lib_mpc_1.MpsVrfUtils.generateVrfDKGKeyShares();
+        const mpcRoots = {
+            ...roots,
+            eddsaMpc: {
+                user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },
+                backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },
+                bitgo: bitgoDkg.getCommonKeychain(),
+            },
+        };
+        const result = await (0, recovery_1.deriveSafeWalletKeys)({ coin: 'sol', slot: 'eddsaMpc', account: 0, roots: mpcRoots });
+        if (result.slot !== 'eddsaMpc') {
+            throw new Error('expected eddsaMpc slot');
+        }
+        result.path.should.equal("m/44'/501'/4'/0'");
+        // Play mint's user↔BitGo role locally at the same BIP44 path; no dev-minted wallet is needed.
+        const userMint = new sdk_lib_mpc_1.MpsDerive.Derive(3, 2, 0, userDkg.getKeyShare(), vrfUser.getKeyShare(), result.path);
+        const bitgoMint = new sdk_lib_mpc_1.MpsDerive.Derive(3, 2, 2, bitgoDkg.getKeyShare(), vrfBitgo.getKeyShare(), result.path);
+        const [userRound0, bitgoRound0] = await Promise.all([userMint.initDerive(), bitgoMint.initDerive()]);
+        const [userRound1] = userMint.handleIncomingMessages([bitgoRound0]);
+        const [bitgoRound1] = bitgoMint.handleIncomingMessages([userRound0]);
+        if (!userRound1 || !bitgoRound1) {
+            throw new Error('expected user and BitGo derive round-1 messages');
+        }
+        assert_1.default.deepStrictEqual(userMint.handleIncomingMessages([bitgoRound1]), []);
+        assert_1.default.deepStrictEqual(bitgoMint.handleIncomingMessages([userRound1]), []);
+        const mintedChildCommonKeychain = userMint.getCommonKeychain();
+        assert_1.default.strictEqual(bitgoMint.getCommonKeychain(), mintedChildCommonKeychain);
+        assert_1.default.strictEqual(result.keys.commonKeychain, mintedChildCommonKeychain);
+        const walletPassphrase = 'safe-recovery-passphrase';
+        const userKey = sjcl.encrypt(walletPassphrase, result.keys.user);
+        const backupKey = sjcl.encrypt(walletPassphrase, result.keys.backup);
+        const rootCommonKeychain = userDkg.getCommonKeychain();
+        await assert_1.default.rejects((0, eddsaMPCv2_1.signEddsaMpcV2RecoveryTx)({
+            message: Buffer.from('wrong keychain must fail'),
+            userKey,
+            backupKey,
+            walletPassphrase,
+            bitgoKey: rootCommonKeychain,
+            derivationPath: 'm/0',
+        }), /commonKeyChain from keycard does not match bitgoKey/);
+        const mpc = await (0, eddsa_1.getInitializedMpcInstance)();
+        for (const derivationPath of ['m/0', 'm/3']) {
+            const message = Buffer.from(`Safe EdDSA recovery ${derivationPath}`);
+            const signature = await (0, eddsaMPCv2_1.signEddsaMpcV2RecoveryTx)({
+                message,
+                userKey,
+                backupKey,
+                walletPassphrase,
+                bitgoKey: result.keys.commonKeychain,
+                derivationPath,
+            });
+            const derivedKeychain = mpc.deriveUnhardened(result.keys.commonKeychain, derivationPath);
+            const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');
+            assert_1.default.strictEqual(ed25519_1.ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes)), true);
+        }
+    });
+    it('derives the ed25519Multisig triplet at the BIP44 path', async () => {
+        const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';
+        const backupChainCode = Buffer.alloc(32, 0xab);
+        // Distinct BitGo root + chain code: if the BitGo composite were derived from the backup root, the
+        // backup child and the BitGo child would be the same key and a slot swap would pass every golden.
+        const bitgoSeed = Buffer.alloc(32, 0x22);
+        const bitgoRootPub = Buffer.from(ed25519_1.ed25519.getPublicKey(bitgoSeed));
+        const bitgoChainCode = Buffer.alloc(32, 0xcd);
+        const ed25519Roots = {
+            ...roots,
+            ed25519Multisig: {
+                user: STRKEY_SEED,
+                backup: { prv: STRKEY_SEED, chainCode: (0, src_1.encodeEd25519ChainCode)(backupChainCode) },
+                bitgo: (0, src_1.encodeDerivableEd25519Pub)(bitgoRootPub, bitgoChainCode),
+            },
+        };
+        const result = await (0, recovery_1.deriveSafeWalletKeys)({
+            coin: 'algo',
+            slot: 'ed25519Multisig',
+            account: 0,
+            roots: ed25519Roots,
+        });
+        if (result.slot !== 'ed25519Multisig') {
+            throw new Error('expected ed25519Multisig slot');
+        }
+        result.path.should.equal("m/44'/283'/2'/0'");
+        // user: hardened SLIP-0010 child, pinned to the leaf's golden vector
+        result.keys.user.kind.should.equal('seed');
+        result.keys.user.seed.should.equal('be69531ebbab851b69aa41bb9c905afed52d26ff4278e6418609d4d60570510c');
+        result.keys.user.pub.should.equal(Buffer.from(ed25519_1.ed25519.getPublicKey(Buffer.from(result.keys.user.seed, 'hex'))).toString('hex'));
+        // backup: extended key whose public half equals the public soft-derive of root pub ‖ chain code
+        const bitgoPub = (await (0, src_1.softDeriveChildPubEd25519AtPath)(ed25519Roots.ed25519Multisig.bitgo, 'm/44/283/2/0')).toString('hex');
+        result.keys.backup.kind.should.equal('extended');
+        // Pin the private halves to the cross-repo GV1 golden vector for this path.
+        const algoSoft = bip44Fixture.ed25519Soft.vectors.find((v) => v.path === 'm/44/283/2/0');
+        if (algoSoft === undefined) {
+            throw new Error('fixture is missing the m/44/283/2/0 soft co-signer vector');
+        }
+        result.keys.backup.kL.should.equal(algoSoft.childKLHex);
+        result.keys.backup.kR.should.equal(algoSoft.childKRHex);
+        // With distinct roots the three children are provably distinct, so a slot swap cannot sneak through.
+        result.keys.user.pub.should.not.equal(result.keys.backup.pub);
+        result.keys.backup.pub.should.not.equal(result.keys.bitgo.pub);
+        result.keys.bitgo.pub.should.equal(bitgoPub);
+    });
+    it('rejects a non-integer account', async () => {
+        await (0, recovery_1.deriveSafeWalletKeys)({ coin: 'btc', slot: 'secp256k1Multisig', account: 1.5, roots }).should.be.rejectedWith(/invalid account/);
+    });
+});
+describe('buildSafeRecoverKeyParams', () => {
+    afterEach(() => {
+        sinon.restore();
+    });
+    const userRoot = utxo_lib_1.bip32.fromSeed(Buffer.from('000102030405060708090a0b0c0d0e0f', 'hex'));
+    const backupRoot = utxo_lib_1.bip32.fromSeed(Buffer.from('1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100', 'hex'));
+    const bitgoRoot = utxo_lib_1.bip32
+        .fromSeed(Buffer.from('2f2e2d2c2b2a292827262524232221201f1e1d1c1b1a19181716151413121110', 'hex'))
+        .neutered();
+    const keys = {
+        user: { prv: userRoot.toBase58(), pub: userRoot.neutered().toBase58() },
+        backup: { prv: backupRoot.toBase58(), pub: backupRoot.neutered().toBase58() },
+        bitgo: { pub: bitgoRoot.toBase58() },
+    };
+    it('signed mode re-encrypts child xprvs under a single ephemeral passphrase', async () => {
+        const passphrases = [];
+        const encrypt = sinon.stub().callsFake(async ({ input, password, encryptionVersion }) => {
+            passphrases.push(password);
+            encryptionVersion.should.equal(1);
+            return `enc(${input})`;
+        });
+        const bitgo = { encrypt };
+        const result = await (0, recovery_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'btc',
+            slot: 'secp256k1Multisig',
+            keys,
+            mode: 'signed',
+        });
+        result.userKey.should.equal(`enc(${keys.user.prv})`);
+        result.backupKey.should.equal(`enc(${keys.backup.prv})`);
+        result.bitgoKey.should.equal(keys.bitgo.pub);
+        result.walletPassphrase.should.be.a.String();
+        passphrases.should.have.length(2);
+        passphrases[0].should.equal(passphrases[1]);
+        passphrases[0].should.equal(result.walletPassphrase);
+        encrypt.callCount.should.equal(2);
+    });
+    it('rejects non-private child keys in signed mode', async () => {
+        const bitgo = { encrypt: sinon.stub() };
+        await (0, recovery_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'btc',
+            slot: 'secp256k1Multisig',
+            keys: { user: { prv: keys.user.pub, pub: keys.user.pub }, backup: keys.backup, bitgo: keys.bitgo },
+            mode: 'signed',
+        }).should.be.rejectedWith(/must be private xprvs/);
+    });
+    it('unsigned mode returns pubs and never encrypts', async () => {
+        const encrypt = sinon.stub().callsFake(async () => {
+            throw new Error('encrypt should not be called');
+        });
+        const bitgo = { encrypt };
+        const result = await (0, recovery_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'btc',
+            slot: 'secp256k1Multisig',
+            keys,
+            mode: 'unsigned',
+        });
+        result.userKey.should.equal(keys.user.pub);
+        result.backupKey.should.equal(keys.backup.pub);
+        result.bitgoKey.should.equal(keys.bitgo.pub);
+        result.should.not.have.property('walletPassphrase');
+        encrypt.callCount.should.equal(0);
+    });
+    it('rejects unsupported slots', async () => {
+        const bitgo = { encrypt: sinon.stub() };
+        await (0, recovery_1.buildSafeRecoverKeyParams)({
+            bitgo,
+            coin: 'btc',
+            slot: 'eddsaMpc',
+            keys: { commonKeychain: 'ck', user: 'u', backup: 'b' },
+            mode: 'signed',
+        }).should.be.rejectedWith(/not supported yet/);
+    });
+    describe('ed25519Multisig (algo)', () => {
+        // Golden vectors generated with algosdk: encodeAddress(Buffer.alloc(32, n)) and
+        // multisigAddress({ version: 1, threshold: 2, addrs: [...] }) over the same pubs.
+        const edKeys = {
+            user: { kind: 'seed', seed: '11'.repeat(32), pub: '21'.repeat(32) },
+            backup: { kind: 'extended', kL: '31'.repeat(32), kR: '41'.repeat(32), pub: '51'.repeat(32) },
+            bitgo: { pub: '61'.repeat(32) },
+        };
+        it('unsigned mode returns ALGO addresses and the multisig rootAddress, and never encrypts', async () => {
+            const encrypt = sinon.stub().callsFake(async () => {
+                throw new Error('encrypt should not be called');
+            });
+            const bitgo = { encrypt };
+            const result = await (0, recovery_1.buildSafeRecoverKeyParams)({
+                bitgo,
+                coin: 'algo',
+                slot: 'ed25519Multisig',
+                keys: edKeys,
+                mode: 'unsigned',
+            });
+            if (result.slot !== 'ed25519Multisig' || result.mode !== 'unsigned') {
+                throw new Error('expected unsigned ed25519Multisig key params');
+            }
+            result.userKey.should.equal('EEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQYNI53HM');
+            result.backupKey.should.equal('KFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFI33B3AOY');
+            result.bitgoKey.should.equal('MFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQS3KHEHM');
+            result.rootAddress.should.equal('LHWEIOU2UIPSKCZ3XMKQUKRYY3FM6XTZKBHDMIU737OQQEXQTYSGDFOHDM');
+            result.userKey.should.match(/^[A-Z2-7]{58}$/);
+            result.should.not.have.property('walletPassphrase');
+            result.should.not.have.property('externalBackupSigner');
+            encrypt.callCount.should.equal(0);
+        });
+        it('signed mode encrypts the 58-char seed and returns a lazy external backup signer', async () => {
+            // Real derivation output, with a distinct BitGo root so the backup child and the BitGo child
+            // are different keys — a slot swap between them must change the outputs.
+            const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';
+            const backupChainCode = Buffer.alloc(32, 0xab);
+            const bitgoSeed = Buffer.alloc(32, 0x22);
+            const bitgoRootPub = Buffer.from(ed25519_1.ed25519.getPublicKey(bitgoSeed));
+            const bitgoChainCode = Buffer.alloc(32, 0xcd);
+            const ed25519Roots = {
+                ...makeRoots({ user: 'x', backup: 'y', bitgo: 'z' }),
+                ed25519Multisig: {
+                    user: STRKEY_SEED,
+                    backup: { prv: STRKEY_SEED, chainCode: (0, src_1.encodeEd25519ChainCode)(backupChainCode) },
+                    bitgo: (0, src_1.encodeDerivableEd25519Pub)(bitgoRootPub, bitgoChainCode),
+                },
+            };
+            const derived = await (0, recovery_1.deriveSafeWalletKeys)({
+                coin: 'algo',
+                slot: 'ed25519Multisig',
+                account: 0,
+                roots: ed25519Roots,
+            });
+            if (derived.slot !== 'ed25519Multisig') {
+                throw new Error('expected ed25519Multisig slot');
+            }
+            const passphrases = [];
+            const encrypt = sinon.stub().callsFake(async ({ input, password, encryptionVersion }) => {
+                passphrases.push(password);
+                encryptionVersion.should.equal(1);
+                return `enc(${input})`;
+            });
+            const bitgo = { encrypt };
+            const result = await (0, recovery_1.buildSafeRecoverKeyParams)({
+                bitgo,
+                coin: 'talgo',
+                slot: 'ed25519Multisig',
+                keys: derived.keys,
+                mode: 'signed',
+            });
+            if (result.slot !== 'ed25519Multisig' || result.mode !== 'signed') {
+                throw new Error('expected signed ed25519Multisig key params');
+            }
+            derived.keys.user.pub.should.not.equal(derived.keys.backup.pub);
+            derived.keys.backup.pub.should.not.equal(derived.keys.bitgo.pub);
+            // user seed re-encoded as the 58-char ALGO seed before encryption; no backupKey — the
+            // seedless backup child only exists as the lazy signer.
+            result.userKey.should.equal(`enc(${(0, src_1.encodeAlgoKey)(Buffer.from(derived.keys.user.seed, 'hex'))})`);
+            result.should.not.have.property('backupKey');
+            result.bitgoKey.should.equal((0, src_1.encodeAlgoKey)(Buffer.from(derived.keys.bitgo.pub, 'hex')));
+            result.bitgoKey.should.match(/^[A-Z2-7]{58}$/);
+            // The wallet's on-chain address over the three distinct children, in wallet-creation order.
+            result.rootAddress.should.equal((0, src_1.algoMultisigAddress)(1, 2, [
+                Buffer.from(derived.keys.user.pub, 'hex'),
+                Buffer.from(derived.keys.backup.pub, 'hex'),
+                Buffer.from(derived.keys.bitgo.pub, 'hex'),
+            ]));
+            result.rootAddress.should.match(/^[A-Z2-7]{58}$/);
+            result.walletPassphrase.should.be.a.String();
+            passphrases.should.have.length(1);
+            passphrases[0].should.equal(result.walletPassphrase);
+            encrypt.callCount.should.equal(1);
+            // the lazy signer signs with the real extended key halves and its pub matches the backup child
+            result.externalBackupSigner.publicKey.should.equal(derived.keys.backup.pub);
+            const message = Buffer.from('deadbeef', 'hex');
+            const { signature } = await result.externalBackupSigner.sign(message);
+            signature.should.match(/^[0-9a-f]{128}$/);
+            ed25519_1.ed25519
+                .verify(new Uint8Array(Buffer.from(signature, 'hex')), new Uint8Array(message), new Uint8Array(Buffer.from(result.externalBackupSigner.publicKey, 'hex')))
+                .should.equal(true);
+        });
+        it('rejects slot-2 coins that have no registry entry yet', async () => {
+            const bitgo = { encrypt: sinon.stub() };
+            await (0, recovery_1.buildSafeRecoverKeyParams)({
+                bitgo,
+                coin: 'xlm',
+                slot: 'ed25519Multisig',
+                keys: edKeys,
+                mode: 'signed',
+            }).should.be.rejectedWith(/coin 'xlm' ed25519Multisig is not supported yet/);
+        });
+        it('rejects ed25519 children with malformed public keys', async () => {
+            const bitgo = { encrypt: sinon.stub() };
+            await (0, recovery_1.buildSafeRecoverKeyParams)({
+                bitgo,
+                coin: 'algo',
+                slot: 'ed25519Multisig',
+                keys: { ...edKeys, bitgo: { pub: '1234' } },
+                mode: 'unsigned',
+            }).should.be.rejectedWith(/ed25519 child public keys must be 32 bytes/);
+        });
+    });
+});
+describe('Safe ecdsaMpc derive → sign (gate)', function () {
+    it('derives a child, rebuilds 2-of-2 shares, and signs a message verified at m/0', async function () {
+        const [userDkg, backupDkg] = await sdk_lib_mpc_1.DklsUtils.generateDKGKeyShares();
+        const [vrfUser, vrfBackup] = await sdk_lib_mpc_1.DklsVrfUtils.generateVrfDKGKeyShares();
+        const rootCommonKeychain = sdk_lib_mpc_1.DklsTypes.getCommonKeychain(userDkg.getKeyShare());
+        const { commonKeychain, userChild, backupChild } = await sdk_lib_mpc_1.DklsVrfUtils.deriveSafeEcdsaMpcChild({
+            userRoot: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },
+            backupRoot: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },
+            account: 0,
+            coinType: 60,
+            safeSlotOrdinal: 3,
+        });
+        // The derived child must never be the root (the "root envelope in the child position" footgun).
+        commonKeychain.should.not.equal(rootCommonKeychain);
+        // Rebuild 2-of-2 keyshares from the derived reduced CBOR, exactly as the signer's retrofit does.
+        const toRetrofit = (b64) => {
+            const reduced = sdk_lib_mpc_1.DklsTypes.getDecodedReducedKeyShare(Buffer.from(b64, 'base64'));
+            return {
+                xShare: {
+                    x: Buffer.from(reduced.prv).toString('hex'),
+                    y: Buffer.from(reduced.pub).toString('hex'),
+                    chaincode: Buffer.from(reduced.rootChainCode).toString('hex'),
+                },
+                xiList: reduced.xList.slice(0, 2),
+            };
+        };
+        const [user2of2, backup2of2] = await sdk_lib_mpc_1.DklsUtils.generate2of2KeyShares(toRetrofit(userChild), toRetrofit(backupChild));
+        const messageHash = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');
+        const userDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(user2of2.getKeyShare(), 0, 'm/0', messageHash);
+        const backupDsg = new sdk_lib_mpc_1.DklsDsg.Dsg(backup2of2.getKeyShare(), 1, 'm/0', messageHash);
+        const signatureString = sdk_lib_mpc_1.DklsUtils.verifyAndConvertDklsSignature(messageHash, (await sdk_lib_mpc_1.DklsUtils.executeTillRound(5, userDsg, backupDsg)), commonKeychain, 'm/0', undefined, false);
+        // verifyAndConvertDklsSignature recovers the pubkey from the signature and checks it against
+        // deriveUnhardened(childCK, 'm/0'); it throws on mismatch, so a returned string is proof.
+        signatureString.should.be.a.String();
+        signatureString.should.match(/^\d+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+$/);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"recovery.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/recovery.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport 'should';\nimport * as sinon from 'sinon';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport { ed25519 } from '@noble/curves/ed25519';\nimport * as sjcl from '@bitgo-beta/sjcl';\nimport { DklsDsg, DklsTypes, DklsUtils, DklsVrfUtils, MPSUtil, MpsDerive, MpsVrfUtils } from '@bitgo-beta/sdk-lib-mpc';\nimport { buildSafeMpcKeyEnvelopes } from '../../../../src/bitgo/utils/tss/keyShareEnvelope';\nimport { IncorrectPasswordError } from '../../../../src/bitgo/errors';\nimport {\n  DecryptedSafeRoots,\n  buildSafeRecoverKeyParams,\n  decryptSafeKeycard,\n  deriveSafeWalletKeys,\n} from '../../../../src/bitgo/safe/recovery';\nimport {\n  algoMultisigAddress,\n  encodeAlgoKey,\n  encodeDerivableEd25519Pub,\n  encodeEd25519ChainCode,\n  softDeriveChildPubEd25519AtPath,\n} from '../../../../src';\nimport { BitGoBase } from '../../../../src/bitgo/bitgoBase';\nimport { getInitializedMpcInstance } from '../../../../src/bitgo/tss/eddsa/eddsa';\nimport { signEddsaMpcV2RecoveryTx } from '../../../../src/bitgo/utils/tss/eddsa/eddsaMPCv2';\n\n// The ed25519 soft co-signer private halves asserted below are pinned cross-repo in the shared\n// GV1 fixture (byte-identical to wallet-platform's copy).\nimport * as bip44Fixture from './fixtures/safeBip44Vectors.json';\n\nconst PASSWORD = 'safe-password';\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  } as unknown as BitGoBase;\n}\n\n/** A fake decrypt that only recognizes the user/backup tokens; any other input (e.g. a Box C public) throws. */\nfunction makeDecryptMap(entries: Record<string, string>): (params: { password: string; input: string }) => string {\n  return ({ password, input }) => {\n    password.should.equal(PASSWORD);\n    if (!(input in entries)) {\n      throw new Error(`unexpected decrypt input: ${input}`);\n    }\n    return entries[input];\n  };\n}\n\nfunction box(values: {\n  secp256k1Multisig: string;\n  ed25519Multisig: string | { prv: string; chainCode: string };\n  ecdsaMpc: string;\n  eddsaMpc: string;\n}): string {\n  return JSON.stringify(values);\n}\n\ndescribe('decryptSafeKeycard', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  it('decrypts onchain roots to strings and returns Box C verbatim', async () => {\n    const userBox = box({\n      secp256k1Multisig: 'enc-user-secp',\n      ed25519Multisig: 'enc-user-ed25519',\n      ecdsaMpc: 'enc-user-ecdsa',\n      eddsaMpc: 'enc-user-eddsa',\n    });\n    const backupBox = box({\n      secp256k1Multisig: 'enc-backup-secp',\n      ed25519Multisig: { prv: 'enc-backup-ed25519', chainCode: 'C'.repeat(52) },\n      ecdsaMpc: 'enc-backup-ecdsa',\n      eddsaMpc: 'enc-backup-eddsa',\n    });\n    const bitgoBox = box({\n      secp256k1Multisig: 'xpub-secp-bitgo',\n      ed25519Multisig: 'pub-ed25519-bitgo',\n      ecdsaMpc: 'common-ecdsa-bitgo',\n      eddsaMpc: 'common-eddsa-bitgo',\n    });\n\n    const mpcUser = buildSafeMpcKeyEnvelopes(\n      Buffer.from('user-signing'),\n      Buffer.from('user-reduced'),\n      Buffer.from('user-vrf')\n    );\n    const mpcBackup = buildSafeMpcKeyEnvelopes(\n      Buffer.from('backup-signing'),\n      Buffer.from('backup-reduced'),\n      Buffer.from('backup-vrf')\n    );\n\n    const bitgo = makeMockBitGo(\n      makeDecryptMap({\n        'enc-user-secp': 'xprv-user',\n        'enc-backup-secp': 'xprv-backup',\n        'enc-user-ed25519': 'S-user-seed',\n        'enc-backup-ed25519': 'S-backup-seed',\n        'enc-user-ecdsa': mpcUser.reducedEnvelope.toString('base64'),\n        'enc-backup-ecdsa': mpcBackup.reducedEnvelope.toString('base64'),\n        'enc-user-eddsa': mpcUser.reducedEnvelope.toString('base64'),\n        'enc-backup-eddsa': mpcBackup.reducedEnvelope.toString('base64'),\n      })\n    );\n\n    const result = await decryptSafeKeycard({\n      bitgo,\n      userKeyBox: userBox,\n      backupKeyBox: backupBox,\n      bitgoKeyBox: bitgoBox,\n      password: PASSWORD,\n    });\n\n    result.secp256k1Multisig.user.should.equal('xprv-user');\n    result.secp256k1Multisig.backup.should.equal('xprv-backup');\n    result.secp256k1Multisig.bitgo.should.equal('xpub-secp-bitgo');\n\n    result.ed25519Multisig.user.should.equal('S-user-seed');\n    result.ed25519Multisig.backup.prv.should.equal('S-backup-seed');\n    result.ed25519Multisig.backup.chainCode.should.equal('C'.repeat(52));\n    result.ed25519Multisig.bitgo.should.equal('pub-ed25519-bitgo');\n\n    result.ecdsaMpc.user.signing.toString('hex').should.equal(Buffer.from('user-reduced').toString('hex'));\n    result.ecdsaMpc.user.vrf.toString('hex').should.equal(Buffer.from('user-vrf').toString('hex'));\n    result.ecdsaMpc.backup.signing.toString('hex').should.equal(Buffer.from('backup-reduced').toString('hex'));\n    result.ecdsaMpc.backup.vrf.toString('hex').should.equal(Buffer.from('backup-vrf').toString('hex'));\n    result.ecdsaMpc.bitgo.should.equal('common-ecdsa-bitgo');\n\n    result.eddsaMpc.bitgo.should.equal('common-eddsa-bitgo');\n\n    // 4 slots × (user + backup) = 8 decrypts; BitGo (Box C) is never decrypted.\n    (bitgo.decrypt as sinon.SinonStub).callCount.should.equal(8);\n  });\n\n  it('decrypts the seed from an object-form ed25519Multisig backup entry', async () => {\n    const userBox = box({\n      secp256k1Multisig: 'enc-user-secp',\n      ed25519Multisig: 'enc-user-ed25519',\n      ecdsaMpc: 'enc-user-ecdsa',\n      eddsaMpc: 'enc-user-eddsa',\n    });\n    const backupBox = JSON.stringify({\n      secp256k1Multisig: 'enc-backup-secp',\n      ed25519Multisig: { prv: 'enc-backup-ed25519', chainCode: 'A'.repeat(52) },\n      ecdsaMpc: 'enc-backup-ecdsa',\n      eddsaMpc: 'enc-backup-eddsa',\n    });\n    const bitgoBox = box({\n      secp256k1Multisig: 'xpub-secp-bitgo',\n      ed25519Multisig: 'pub-ed25519-bitgo',\n      ecdsaMpc: 'common-ecdsa-bitgo',\n      eddsaMpc: 'common-eddsa-bitgo',\n    });\n\n    const mpcUser = buildSafeMpcKeyEnvelopes(\n      Buffer.from('user-signing'),\n      Buffer.from('user-reduced'),\n      Buffer.from('user-vrf')\n    );\n    const mpcBackup = buildSafeMpcKeyEnvelopes(\n      Buffer.from('backup-signing'),\n      Buffer.from('backup-reduced'),\n      Buffer.from('backup-vrf')\n    );\n\n    const bitgo = makeMockBitGo(\n      makeDecryptMap({\n        'enc-user-secp': 'xprv-user',\n        'enc-backup-secp': 'xprv-backup',\n        'enc-user-ed25519': 'S-user-seed',\n        'enc-backup-ed25519': 'S-backup-seed',\n        'enc-user-ecdsa': mpcUser.reducedEnvelope.toString('base64'),\n        'enc-backup-ecdsa': mpcBackup.reducedEnvelope.toString('base64'),\n        'enc-user-eddsa': mpcUser.reducedEnvelope.toString('base64'),\n        'enc-backup-eddsa': mpcBackup.reducedEnvelope.toString('base64'),\n      })\n    );\n\n    const result = await decryptSafeKeycard({\n      bitgo,\n      userKeyBox: userBox,\n      backupKeyBox: backupBox,\n      bitgoKeyBox: bitgoBox,\n      password: PASSWORD,\n    });\n\n    result.ed25519Multisig.backup.prv.should.equal('S-backup-seed');\n    result.ed25519Multisig.backup.chainCode.should.equal('A'.repeat(52));\n  });\n\n  it('rejects an ed25519 chain-code entry in a non-backup slot (fail closed)', async () => {\n    const userBox = JSON.stringify({\n      secp256k1Multisig: { prv: 'enc-user-secp', chainCode: 'A'.repeat(52) },\n      ed25519Multisig: 'enc-user-ed25519',\n      ecdsaMpc: 'enc-user-ecdsa',\n      eddsaMpc: 'enc-user-eddsa',\n    });\n\n    await decryptSafeKeycard({\n      bitgo: makeMockBitGo(makeDecryptMap({})),\n      userKeyBox: userBox,\n      backupKeyBox: userBox,\n      bitgoKeyBox: userBox,\n      password: PASSWORD,\n    }).should.be.rejectedWith(/unexpected ed25519 chain-code entry/);\n  });\n\n  it('throws IncorrectPasswordError when decryption fails (wrong password)', async () => {\n    const userBox = box({\n      secp256k1Multisig: 'enc-user-secp',\n      ed25519Multisig: 'enc-user-ed25519',\n      ecdsaMpc: 'enc-user-ecdsa',\n      eddsaMpc: 'enc-user-eddsa',\n    });\n    const bitgo = makeMockBitGo(() => {\n      throw new Error('argon2: tag does not match');\n    });\n\n    await decryptSafeKeycard({\n      bitgo,\n      userKeyBox: userBox,\n      backupKeyBox: userBox,\n      bitgoKeyBox: userBox,\n      password: 'wrong-password',\n    }).should.be.rejectedWith(IncorrectPasswordError);\n  });\n});\n\nconst MPC_ROOT = { signing: Buffer.alloc(0), vrf: Buffer.alloc(0) };\n\nfunction makeRoots(secp: { user: string; backup: string; bitgo: string }): DecryptedSafeRoots {\n  return {\n    secp256k1Multisig: secp,\n    ed25519Multisig: { user: 'u', backup: { prv: 'b', chainCode: 'c' }, bitgo: 'g' },\n    ecdsaMpc: { user: MPC_ROOT, backup: MPC_ROOT, bitgo: 'g' },\n    eddsaMpc: { user: MPC_ROOT, backup: MPC_ROOT, bitgo: 'g' },\n  };\n}\n\ndescribe('deriveSafeWalletKeys', () => {\n  const userRoot = bip32.fromSeed(Buffer.from('000102030405060708090a0b0c0d0e0f', 'hex'));\n  const backupRoot = bip32.fromSeed(\n    Buffer.from('1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100', 'hex')\n  );\n  const bitgoRoot = bip32\n    .fromSeed(Buffer.from('2f2e2d2c2b2a292827262524232221201f1e1d1c1b1a19181716151413121110', 'hex'))\n    .neutered();\n\n  const roots = makeRoots({\n    user: userRoot.toBase58(),\n    backup: backupRoot.toBase58(),\n    bitgo: bitgoRoot.toBase58(),\n  });\n\n  it('derives the BIP44 child triplet for slot 1', async () => {\n    const result = await deriveSafeWalletKeys({ coin: 'btc', slot: 'secp256k1Multisig', account: 0, roots });\n    if (result.slot !== 'secp256k1Multisig') {\n      throw new Error('expected secp256k1Multisig slot');\n    }\n\n    result.path.should.equal(\"m/44'/0'/1'/0'\");\n    result.keys.user.prv.should.equal(userRoot.derivePath(\"m/44'/0'/1'/0'\").toBase58());\n    result.keys.user.pub.should.equal(userRoot.derivePath(\"m/44'/0'/1'/0'\").neutered().toBase58());\n    result.keys.backup.prv.should.equal(backupRoot.derivePath('m/44/0/1/0').toBase58());\n    result.keys.bitgo.pub.should.equal(bitgoRoot.derivePath('m/44/0/1/0').toBase58());\n  });\n\n  it('varies the path with the account', async () => {\n    const result = await deriveSafeWalletKeys({ coin: 'btc', slot: 'secp256k1Multisig', account: 2, roots });\n    result.path.should.equal(\"m/44'/0'/1'/2'\");\n  });\n\n  it('derives the ecdsaMpc child via the DKLs ceremony', async () => {\n    const [userDkg, backupDkg] = await DklsUtils.generateDKGKeyShares();\n    const [vrfUser, vrfBackup] = await DklsVrfUtils.generateVrfDKGKeyShares();\n\n    const mpcRoots: DecryptedSafeRoots = {\n      ...roots,\n      ecdsaMpc: {\n        user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },\n        backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },\n        bitgo: 'g',\n      },\n    };\n\n    const result = await deriveSafeWalletKeys({ coin: 'eth', slot: 'ecdsaMpc', account: 0, roots: mpcRoots });\n    if (result.slot !== 'ecdsaMpc') {\n      throw new Error('expected ecdsaMpc slot');\n    }\n\n    result.path.should.equal(\"m/44'/60'/3'/0'\");\n    result.keys.commonKeychain.should.be.a.String();\n    result.keys.user.should.be.a.String();\n    result.keys.backup.should.be.a.String();\n  });\n\n  it('derives and signs the eddsaMpc slot-4 BIP44 child', async function () {\n    const [userDkg, backupDkg, bitgoDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n    const [vrfUser, vrfBackup, vrfBitgo] = await MpsVrfUtils.generateVrfDKGKeyShares();\n    const mpcRoots: DecryptedSafeRoots = {\n      ...roots,\n      eddsaMpc: {\n        user: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },\n        backup: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },\n        bitgo: bitgoDkg.getCommonKeychain(),\n      },\n    };\n\n    const result = await deriveSafeWalletKeys({ coin: 'sol', slot: 'eddsaMpc', account: 0, roots: mpcRoots });\n    if (result.slot !== 'eddsaMpc') {\n      throw new Error('expected eddsaMpc slot');\n    }\n    result.path.should.equal(\"m/44'/501'/4'/0'\");\n\n    // Play mint's user↔BitGo role locally at the same BIP44 path; no dev-minted wallet is needed.\n    const userMint = new MpsDerive.Derive(3, 2, 0, userDkg.getKeyShare(), vrfUser.getKeyShare(), result.path);\n    const bitgoMint = new MpsDerive.Derive(3, 2, 2, bitgoDkg.getKeyShare(), vrfBitgo.getKeyShare(), result.path);\n    const [userRound0, bitgoRound0] = await Promise.all([userMint.initDerive(), bitgoMint.initDerive()]);\n    const [userRound1] = userMint.handleIncomingMessages([bitgoRound0]);\n    const [bitgoRound1] = bitgoMint.handleIncomingMessages([userRound0]);\n    if (!userRound1 || !bitgoRound1) {\n      throw new Error('expected user and BitGo derive round-1 messages');\n    }\n    assert.deepStrictEqual(userMint.handleIncomingMessages([bitgoRound1]), []);\n    assert.deepStrictEqual(bitgoMint.handleIncomingMessages([userRound1]), []);\n    const mintedChildCommonKeychain = userMint.getCommonKeychain();\n    assert.strictEqual(bitgoMint.getCommonKeychain(), mintedChildCommonKeychain);\n    assert.strictEqual(result.keys.commonKeychain, mintedChildCommonKeychain);\n\n    const walletPassphrase = 'safe-recovery-passphrase';\n    const userKey = sjcl.encrypt(walletPassphrase, result.keys.user);\n    const backupKey = sjcl.encrypt(walletPassphrase, result.keys.backup);\n    const rootCommonKeychain = userDkg.getCommonKeychain();\n    await assert.rejects(\n      signEddsaMpcV2RecoveryTx({\n        message: Buffer.from('wrong keychain must fail'),\n        userKey,\n        backupKey,\n        walletPassphrase,\n        bitgoKey: rootCommonKeychain,\n        derivationPath: 'm/0',\n      }),\n      /commonKeyChain from keycard does not match bitgoKey/\n    );\n\n    const mpc = await getInitializedMpcInstance();\n    for (const derivationPath of ['m/0', 'm/3']) {\n      const message = Buffer.from(`Safe EdDSA recovery ${derivationPath}`);\n      const signature = await signEddsaMpcV2RecoveryTx({\n        message,\n        userKey,\n        backupKey,\n        walletPassphrase,\n        bitgoKey: result.keys.commonKeychain,\n        derivationPath,\n      });\n      const derivedKeychain = mpc.deriveUnhardened(result.keys.commonKeychain, derivationPath);\n      const publicKeyBytes = Buffer.from(derivedKeychain.slice(0, 64), 'hex');\n      assert.strictEqual(\n        ed25519.verify(new Uint8Array(signature), new Uint8Array(message), new Uint8Array(publicKeyBytes)),\n        true\n      );\n    }\n  });\n\n  it('derives the ed25519Multisig triplet at the BIP44 path', async () => {\n    const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';\n    const backupChainCode = Buffer.alloc(32, 0xab);\n    // Distinct BitGo root + chain code: if the BitGo composite were derived from the backup root, the\n    // backup child and the BitGo child would be the same key and a slot swap would pass every golden.\n    const bitgoSeed = Buffer.alloc(32, 0x22);\n    const bitgoRootPub = Buffer.from(ed25519.getPublicKey(bitgoSeed));\n    const bitgoChainCode = Buffer.alloc(32, 0xcd);\n    const ed25519Roots: DecryptedSafeRoots = {\n      ...roots,\n      ed25519Multisig: {\n        user: STRKEY_SEED,\n        backup: { prv: STRKEY_SEED, chainCode: encodeEd25519ChainCode(backupChainCode) },\n        bitgo: encodeDerivableEd25519Pub(bitgoRootPub, bitgoChainCode),\n      },\n    };\n\n    const result = await deriveSafeWalletKeys({\n      coin: 'algo',\n      slot: 'ed25519Multisig',\n      account: 0,\n      roots: ed25519Roots,\n    });\n    if (result.slot !== 'ed25519Multisig') {\n      throw new Error('expected ed25519Multisig slot');\n    }\n\n    result.path.should.equal(\"m/44'/283'/2'/0'\");\n\n    // user: hardened SLIP-0010 child, pinned to the leaf's golden vector\n    result.keys.user.kind.should.equal('seed');\n    result.keys.user.seed.should.equal('be69531ebbab851b69aa41bb9c905afed52d26ff4278e6418609d4d60570510c');\n    result.keys.user.pub.should.equal(\n      Buffer.from(ed25519.getPublicKey(Buffer.from(result.keys.user.seed, 'hex'))).toString('hex')\n    );\n\n    // backup: extended key whose public half equals the public soft-derive of root pub ‖ chain code\n    const bitgoPub = (\n      await softDeriveChildPubEd25519AtPath(ed25519Roots.ed25519Multisig.bitgo, 'm/44/283/2/0')\n    ).toString('hex');\n    result.keys.backup.kind.should.equal('extended');\n    // Pin the private halves to the cross-repo GV1 golden vector for this path.\n    const algoSoft = bip44Fixture.ed25519Soft.vectors.find((v) => v.path === 'm/44/283/2/0');\n    if (algoSoft === undefined) {\n      throw new Error('fixture is missing the m/44/283/2/0 soft co-signer vector');\n    }\n    result.keys.backup.kL.should.equal(algoSoft.childKLHex);\n    result.keys.backup.kR.should.equal(algoSoft.childKRHex);\n    // With distinct roots the three children are provably distinct, so a slot swap cannot sneak through.\n    result.keys.user.pub.should.not.equal(result.keys.backup.pub);\n    result.keys.backup.pub.should.not.equal(result.keys.bitgo.pub);\n    result.keys.bitgo.pub.should.equal(bitgoPub);\n  });\n\n  it('rejects a non-integer account', async () => {\n    await deriveSafeWalletKeys({ coin: 'btc', slot: 'secp256k1Multisig', account: 1.5, roots }).should.be.rejectedWith(\n      /invalid account/\n    );\n  });\n});\n\ndescribe('buildSafeRecoverKeyParams', () => {\n  afterEach(() => {\n    sinon.restore();\n  });\n\n  const userRoot = bip32.fromSeed(Buffer.from('000102030405060708090a0b0c0d0e0f', 'hex'));\n  const backupRoot = bip32.fromSeed(\n    Buffer.from('1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100', 'hex')\n  );\n  const bitgoRoot = bip32\n    .fromSeed(Buffer.from('2f2e2d2c2b2a292827262524232221201f1e1d1c1b1a19181716151413121110', 'hex'))\n    .neutered();\n\n  const keys = {\n    user: { prv: userRoot.toBase58(), pub: userRoot.neutered().toBase58() },\n    backup: { prv: backupRoot.toBase58(), pub: backupRoot.neutered().toBase58() },\n    bitgo: { pub: bitgoRoot.toBase58() },\n  };\n\n  it('signed mode re-encrypts child xprvs under a single ephemeral passphrase', async () => {\n    const passphrases: string[] = [];\n    const encrypt = sinon.stub().callsFake(async ({ input, password, encryptionVersion }) => {\n      passphrases.push(password);\n      encryptionVersion.should.equal(1);\n      return `enc(${input})`;\n    });\n    const bitgo = { encrypt } as unknown as BitGoBase;\n\n    const result = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'btc',\n      slot: 'secp256k1Multisig',\n      keys,\n      mode: 'signed',\n    });\n\n    result.userKey.should.equal(`enc(${keys.user.prv})`);\n    result.backupKey.should.equal(`enc(${keys.backup.prv})`);\n    result.bitgoKey.should.equal(keys.bitgo.pub);\n    (result.walletPassphrase as string).should.be.a.String();\n    passphrases.should.have.length(2);\n    passphrases[0].should.equal(passphrases[1]);\n    passphrases[0].should.equal(result.walletPassphrase);\n    encrypt.callCount.should.equal(2);\n  });\n\n  it('rejects non-private child keys in signed mode', async () => {\n    const bitgo = { encrypt: sinon.stub() } as unknown as BitGoBase;\n    await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'btc',\n      slot: 'secp256k1Multisig',\n      keys: { user: { prv: keys.user.pub, pub: keys.user.pub }, backup: keys.backup, bitgo: keys.bitgo },\n      mode: 'signed',\n    }).should.be.rejectedWith(/must be private xprvs/);\n  });\n\n  it('unsigned mode returns pubs and never encrypts', async () => {\n    const encrypt = sinon.stub().callsFake(async () => {\n      throw new Error('encrypt should not be called');\n    });\n    const bitgo = { encrypt } as unknown as BitGoBase;\n\n    const result = await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'btc',\n      slot: 'secp256k1Multisig',\n      keys,\n      mode: 'unsigned',\n    });\n\n    result.userKey.should.equal(keys.user.pub);\n    result.backupKey.should.equal(keys.backup.pub);\n    result.bitgoKey.should.equal(keys.bitgo.pub);\n    result.should.not.have.property('walletPassphrase');\n    encrypt.callCount.should.equal(0);\n  });\n\n  it('rejects unsupported slots', async () => {\n    const bitgo = { encrypt: sinon.stub() } as unknown as BitGoBase;\n    await buildSafeRecoverKeyParams({\n      bitgo,\n      coin: 'btc',\n      slot: 'eddsaMpc',\n      keys: { commonKeychain: 'ck', user: 'u', backup: 'b' },\n      mode: 'signed',\n    }).should.be.rejectedWith(/not supported yet/);\n  });\n\n  describe('ed25519Multisig (algo)', () => {\n    // Golden vectors generated with algosdk: encodeAddress(Buffer.alloc(32, n)) and\n    // multisigAddress({ version: 1, threshold: 2, addrs: [...] }) over the same pubs.\n    const edKeys = {\n      user: { kind: 'seed', seed: '11'.repeat(32), pub: '21'.repeat(32) },\n      backup: { kind: 'extended', kL: '31'.repeat(32), kR: '41'.repeat(32), pub: '51'.repeat(32) },\n      bitgo: { pub: '61'.repeat(32) },\n    } as const;\n\n    it('unsigned mode returns ALGO addresses and the multisig rootAddress, and never encrypts', async () => {\n      const encrypt = sinon.stub().callsFake(async () => {\n        throw new Error('encrypt should not be called');\n      });\n      const bitgo = { encrypt } as unknown as BitGoBase;\n\n      const result = await buildSafeRecoverKeyParams({\n        bitgo,\n        coin: 'algo',\n        slot: 'ed25519Multisig',\n        keys: edKeys,\n        mode: 'unsigned',\n      });\n      if (result.slot !== 'ed25519Multisig' || result.mode !== 'unsigned') {\n        throw new Error('expected unsigned ed25519Multisig key params');\n      }\n\n      result.userKey.should.equal('EEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQSCIJBEEQYNI53HM');\n      result.backupKey.should.equal('KFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFIVCUKRKFI33B3AOY');\n      result.bitgoKey.should.equal('MFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQWCYLBMFQS3KHEHM');\n      result.rootAddress.should.equal('LHWEIOU2UIPSKCZ3XMKQUKRYY3FM6XTZKBHDMIU737OQQEXQTYSGDFOHDM');\n      result.userKey.should.match(/^[A-Z2-7]{58}$/);\n      result.should.not.have.property('walletPassphrase');\n      result.should.not.have.property('externalBackupSigner');\n      encrypt.callCount.should.equal(0);\n    });\n\n    it('signed mode encrypts the 58-char seed and returns a lazy external backup signer', async () => {\n      // Real derivation output, with a distinct BitGo root so the backup child and the BitGo child\n      // are different keys — a slot swap between them must change the outputs.\n      const STRKEY_SEED = 'SAAACAQDAQCQMBYIBEFAWDANBYHRAEISCMKBKFQXDAMRUGY4DUPB6NKI';\n      const backupChainCode = Buffer.alloc(32, 0xab);\n      const bitgoSeed = Buffer.alloc(32, 0x22);\n      const bitgoRootPub = Buffer.from(ed25519.getPublicKey(bitgoSeed));\n      const bitgoChainCode = Buffer.alloc(32, 0xcd);\n      const ed25519Roots: DecryptedSafeRoots = {\n        ...makeRoots({ user: 'x', backup: 'y', bitgo: 'z' }),\n        ed25519Multisig: {\n          user: STRKEY_SEED,\n          backup: { prv: STRKEY_SEED, chainCode: encodeEd25519ChainCode(backupChainCode) },\n          bitgo: encodeDerivableEd25519Pub(bitgoRootPub, bitgoChainCode),\n        },\n      };\n      const derived = await deriveSafeWalletKeys({\n        coin: 'algo',\n        slot: 'ed25519Multisig',\n        account: 0,\n        roots: ed25519Roots,\n      });\n      if (derived.slot !== 'ed25519Multisig') {\n        throw new Error('expected ed25519Multisig slot');\n      }\n\n      const passphrases: string[] = [];\n      const encrypt = sinon.stub().callsFake(async ({ input, password, encryptionVersion }) => {\n        passphrases.push(password);\n        encryptionVersion.should.equal(1);\n        return `enc(${input})`;\n      });\n      const bitgo = { encrypt } as unknown as BitGoBase;\n\n      const result = await buildSafeRecoverKeyParams({\n        bitgo,\n        coin: 'talgo',\n        slot: 'ed25519Multisig',\n        keys: derived.keys,\n        mode: 'signed',\n      });\n      if (result.slot !== 'ed25519Multisig' || result.mode !== 'signed') {\n        throw new Error('expected signed ed25519Multisig key params');\n      }\n\n      derived.keys.user.pub.should.not.equal(derived.keys.backup.pub);\n      derived.keys.backup.pub.should.not.equal(derived.keys.bitgo.pub);\n\n      // user seed re-encoded as the 58-char ALGO seed before encryption; no backupKey — the\n      // seedless backup child only exists as the lazy signer.\n      result.userKey.should.equal(`enc(${encodeAlgoKey(Buffer.from(derived.keys.user.seed, 'hex'))})`);\n      result.should.not.have.property('backupKey');\n      result.bitgoKey.should.equal(encodeAlgoKey(Buffer.from(derived.keys.bitgo.pub, 'hex')));\n      result.bitgoKey.should.match(/^[A-Z2-7]{58}$/);\n      // The wallet's on-chain address over the three distinct children, in wallet-creation order.\n      result.rootAddress.should.equal(\n        algoMultisigAddress(1, 2, [\n          Buffer.from(derived.keys.user.pub, 'hex'),\n          Buffer.from(derived.keys.backup.pub, 'hex'),\n          Buffer.from(derived.keys.bitgo.pub, 'hex'),\n        ])\n      );\n      result.rootAddress.should.match(/^[A-Z2-7]{58}$/);\n      result.walletPassphrase.should.be.a.String();\n      passphrases.should.have.length(1);\n      passphrases[0].should.equal(result.walletPassphrase);\n      encrypt.callCount.should.equal(1);\n\n      // the lazy signer signs with the real extended key halves and its pub matches the backup child\n      result.externalBackupSigner.publicKey.should.equal(derived.keys.backup.pub);\n      const message = Buffer.from('deadbeef', 'hex');\n      const { signature } = await result.externalBackupSigner.sign(message);\n      signature.should.match(/^[0-9a-f]{128}$/);\n      ed25519\n        .verify(\n          new Uint8Array(Buffer.from(signature, 'hex')),\n          new Uint8Array(message),\n          new Uint8Array(Buffer.from(result.externalBackupSigner.publicKey, 'hex'))\n        )\n        .should.equal(true);\n    });\n\n    it('rejects slot-2 coins that have no registry entry yet', async () => {\n      const bitgo = { encrypt: sinon.stub() } as unknown as BitGoBase;\n      await buildSafeRecoverKeyParams({\n        bitgo,\n        coin: 'xlm',\n        slot: 'ed25519Multisig',\n        keys: edKeys,\n        mode: 'signed',\n      }).should.be.rejectedWith(/coin 'xlm' ed25519Multisig is not supported yet/);\n    });\n\n    it('rejects ed25519 children with malformed public keys', async () => {\n      const bitgo = { encrypt: sinon.stub() } as unknown as BitGoBase;\n      await buildSafeRecoverKeyParams({\n        bitgo,\n        coin: 'algo',\n        slot: 'ed25519Multisig',\n        keys: { ...edKeys, bitgo: { pub: '1234' } },\n        mode: 'unsigned',\n      }).should.be.rejectedWith(/ed25519 child public keys must be 32 bytes/);\n    });\n  });\n});\n\ndescribe('Safe ecdsaMpc derive → sign (gate)', function () {\n  it('derives a child, rebuilds 2-of-2 shares, and signs a message verified at m/0', async function () {\n    const [userDkg, backupDkg] = await DklsUtils.generateDKGKeyShares();\n    const [vrfUser, vrfBackup] = await DklsVrfUtils.generateVrfDKGKeyShares();\n\n    const rootCommonKeychain = DklsTypes.getCommonKeychain(userDkg.getKeyShare());\n\n    const { commonKeychain, userChild, backupChild } = await DklsVrfUtils.deriveSafeEcdsaMpcChild({\n      userRoot: { signing: userDkg.getReducedKeyShare(), vrf: vrfUser.getKeyShare() },\n      backupRoot: { signing: backupDkg.getReducedKeyShare(), vrf: vrfBackup.getKeyShare() },\n      account: 0,\n      coinType: 60,\n      safeSlotOrdinal: 3,\n    });\n\n    // The derived child must never be the root (the \"root envelope in the child position\" footgun).\n    commonKeychain.should.not.equal(rootCommonKeychain);\n\n    // Rebuild 2-of-2 keyshares from the derived reduced CBOR, exactly as the signer's retrofit does.\n    const toRetrofit = (b64: string): DklsTypes.RetrofitData => {\n      const reduced = DklsTypes.getDecodedReducedKeyShare(Buffer.from(b64, 'base64'));\n      return {\n        xShare: {\n          x: Buffer.from(reduced.prv).toString('hex'),\n          y: Buffer.from(reduced.pub).toString('hex'),\n          chaincode: Buffer.from(reduced.rootChainCode).toString('hex'),\n        },\n        xiList: reduced.xList.slice(0, 2),\n      };\n    };\n    const [user2of2, backup2of2] = await DklsUtils.generate2of2KeyShares(\n      toRetrofit(userChild),\n      toRetrofit(backupChild)\n    );\n\n    const messageHash = Buffer.from('0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef', 'hex');\n    const userDsg = new DklsDsg.Dsg(user2of2.getKeyShare(), 0, 'm/0', messageHash);\n    const backupDsg = new DklsDsg.Dsg(backup2of2.getKeyShare(), 1, 'm/0', messageHash);\n    const signatureString = DklsUtils.verifyAndConvertDklsSignature(\n      messageHash,\n      (await DklsUtils.executeTillRound(5, userDsg, backupDsg)) as DklsTypes.DeserializedDklsSignature,\n      commonKeychain,\n      'm/0',\n      undefined,\n      false\n    );\n\n    // verifyAndConvertDklsSignature recovers the pubkey from the signature and checks it against\n    // deriveUnhardened(childCK, 'm/0'); it throws on mismatch, so a returned string is proof.\n    signatureString.should.be.a.String();\n    signatureString.should.match(/^\\d+:[0-9a-f]+:[0-9a-f]+:[0-9a-f]+$/);\n  });\n});\n"]}