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

package/dist/test/unit/bitgo/wallet/safeGetUserPrv.js

@@ -0,0 +1,651 @@
+"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 });
+/**
+ * @prettier
+ */
+require("should");
+const sinon = __importStar(require("sinon"));
+const utxo_lib_1 = require("@bitgo-beta/utxo-lib");
+const src_1 = require("../../../../src");
+const baseCoin_1 = require("../../../../src/bitgo/baseCoin");
+require('should-sinon');
+describe('WCN-1200 safe child getUserPrv root-fetch detour', function () {
+    const prv = 'xprv9s21ZrQH143K3hekyNj7TciR4XNYe1kMj68W2ipjJGNHETWP7o42AjDnSPgKhdZ4x8NBAvaL72RrXjuXNdmkMqLERZza73oYugGtbLFXG8g';
+    const softDerivedNode = baseCoin_1.BaseCoin.deriveKeyWithSeedBip32(utxo_lib_1.bip32.fromBase58(prv), '123');
+    if (!softDerivedNode.key.privateKey) {
+        throw new Error('expected deriveKeyWithSeedBip32 to return a private key');
+    }
+    const softDerivedPrv = softDerivedNode.key.toBase58();
+    const childPath = (0, src_1.buildSafeBip44Path)(0, 'secp256k1Multisig', 123);
+    const hardened = (0, src_1.deriveSafeChildHardenedFromXprv)(prv, childPath);
+    const passphrase = 'test-passphrase';
+    const rootKeyId = 'root-key-id';
+    let mockBitGo;
+    let mockBaseCoin;
+    let keychainsGetStub;
+    let encryptStub;
+    let decryptStub;
+    const baseWalletData = {
+        id: 'wallet-id',
+        coin: 'tbtc',
+        keys: ['user-key', 'backup-key', 'bitgo-key'],
+        type: 'hot',
+        multisigType: 'onchain',
+        enterprise: 'ent-id',
+    };
+    beforeEach(function () {
+        keychainsGetStub = sinon.stub();
+        encryptStub = sinon.stub();
+        decryptStub = sinon.stub();
+        mockBitGo = {
+            encrypt: encryptStub,
+            decrypt: decryptStub,
+            url: sinon.stub().returns('https://test.bitgo.com/'),
+            setRequestTracer: sinon.stub(),
+        };
+        mockBaseCoin = {
+            getChain: sinon.stub().returns('tbtc'),
+            getFamily: sinon.stub().returns('btc'),
+            getFullName: sinon.stub().returns('Test Bitcoin'),
+            keychains: sinon.stub().returns({
+                get: keychainsGetStub,
+                getKeysForSigning: sinon.stub().resolves([]),
+            }),
+            deriveKeyWithSeed: sinon.stub().callsFake(({ key, seed }) => {
+                if (key === prv && seed === '123') {
+                    return { key: softDerivedPrv, derivationPath: 'm/999999/...' };
+                }
+                return { key: `derived(${key},${seed})`, derivationPath: 'm/0' };
+            }),
+            url: sinon.stub().callsFake((path) => `https://test.bitgo.com/api/v2/tbtc${path}`),
+            supportsStaking: sinon.stub().returns(false),
+            supportsTss: sinon.stub().returns(false),
+            getMPCAlgorithm: sinon.stub(),
+            keyIdsForSigning: sinon.stub().returns([0, 1, 2]),
+        };
+        decryptStub.callsFake(({ input, password }) => {
+            if (password !== passphrase) {
+                return null;
+            }
+            if (typeof input === 'string' && input.startsWith('enc:')) {
+                return input.slice(4);
+            }
+            return null;
+        });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    function makeWallet(overrides = {}) {
+        return new src_1.Wallet(mockBitGo, mockBaseCoin, {
+            ...baseWalletData,
+            ...overrides,
+        });
+    }
+    describe('fetchRootKeychainForSafeChild', function () {
+        it('throws when child keychain has no parent', async function () {
+            await (0, src_1.fetchRootKeychainForSafeChild)(mockBaseCoin.keychains(), {
+                id: 'child-key',
+                type: 'independent',
+                pub: 'child-pub',
+            }).should.be.rejectedWith('childKeychain.parent is required to fetch the root keychain');
+            keychainsGetStub.notCalled.should.be.true();
+        });
+        it('throws InvalidRootKeychainSourceError when root source is backup', async function () {
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'backup',
+                encryptedPrv: 'enc:root',
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            await (0, src_1.fetchRootKeychainForSafeChild)(mockBaseCoin.keychains(), {
+                id: 'child-key',
+                parent: rootKeyId,
+                type: 'independent',
+                pub: 'child-pub',
+            }).should.be.rejectedWith(src_1.InvalidRootKeychainSourceError);
+        });
+        it('returns the root keychain when source is user', async function () {
+            const root = {
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: 'enc:root',
+                type: 'independent',
+                pub: 'root-pub',
+            };
+            keychainsGetStub.resolves(root);
+            const result = await (0, src_1.fetchRootKeychainForSafeChild)(mockBaseCoin.keychains(), {
+                id: 'child-key',
+                parent: rootKeyId,
+                type: 'independent',
+                pub: 'child-pub',
+            });
+            result.should.eql(root);
+        });
+        it('throws when root keychain has no encryptedPrv', async function () {
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            await (0, src_1.fetchRootKeychainForSafeChild)(mockBaseCoin.keychains(), {
+                id: 'child-key',
+                parent: rootKeyId,
+                type: 'independent',
+                pub: 'child-pub',
+            }).should.be.rejectedWith(/does not have property encryptedPrv/);
+        });
+    });
+    describe('getUserPrv', function () {
+        it('throws when keychain has no encryptedPrv on a non-safe wallet', async function () {
+            const wallet = makeWallet();
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'pub',
+                    type: 'independent',
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith('keychain does not have property encryptedPrv');
+        });
+        it('throws for a non-safe wallet even when keychain has parent', async function () {
+            const wallet = makeWallet();
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'pub',
+                    type: 'independent',
+                    parent: rootKeyId,
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith('keychain does not have property encryptedPrv');
+            keychainsGetStub.notCalled.should.be.true();
+        });
+        it('throws for a safe wallet when keychain has no parent', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'pub',
+                    type: 'independent',
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith('keychain does not have property encryptedPrv');
+            keychainsGetStub.notCalled.should.be.true();
+        });
+        it('fetches root and hardened-derives child key for safe owner', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            const result = await wallet.getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: hardened.pub,
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithPath: childPath,
+                },
+                walletPassphrase: passphrase,
+            });
+            result.should.eql(hardened.prv);
+            result.should.not.eql(softDerivedPrv);
+            keychainsGetStub.calledOnceWithExactly({ id: rootKeyId }).should.be.true();
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('requires derivedFromParentWithPath on the child keychain', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: hardened.pub,
+                    type: 'independent',
+                    parent: rootKeyId,
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith(/missing derivedFromParentWithPath/);
+        });
+        it('fails closed when derivedFromParentWithPath does not match the registered pub', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: hardened.pub,
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithPath: "m/44'/0'/1'/0'",
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith(src_1.SafeDerivedPublicKeyMismatchError);
+        });
+        for (const storedPath of ["not-a-path'", "m/123'", 'm/44/0/1/123']) {
+            it(`rejects a non-BIP44 derivedFromParentWithPath ${JSON.stringify(storedPath)}`, async function () {
+                const wallet = makeWallet({ safe: 'safe-id-1' });
+                keychainsGetStub.resolves({
+                    id: rootKeyId,
+                    source: 'user',
+                    encryptedPrv: `enc:${prv}`,
+                    type: 'independent',
+                    pub: 'root-pub',
+                });
+                await wallet
+                    .getUserPrv({
+                    keychain: {
+                        id: 'child-key',
+                        pub: hardened.pub,
+                        type: 'independent',
+                        parent: rootKeyId,
+                        derivedFromParentWithPath: storedPath,
+                    },
+                    walletPassphrase: passphrase,
+                })
+                    .should.be.rejectedWith(/derivedFromParentWithPath/);
+            });
+        }
+        it('fails closed for TSS safe owner instead of returning the root prv', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'unrelated-child-pub',
+                    type: 'tss',
+                    parent: rootKeyId,
+                    derivedFromParentWithSeed: '123',
+                    commonKeychain: 'ck',
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith(src_1.SafeOwnerSigningNotImplementedError);
+            keychainsGetStub.notCalled.should.be.true();
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('fails closed for ed25519 onchain safe owner instead of BIP32-deriving', async function () {
+            mockBaseCoin.getFamily.returns('xlm');
+            const wallet = makeWallet({ safe: 'safe-id-1', coin: 'txlm' });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'child-pub',
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithSeed: '123',
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith(src_1.SafeOwnerSigningNotImplementedError);
+            keychainsGetStub.notCalled.should.be.true();
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('aborts locally when derived pub does not match registered child pub', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'xpub-wrong-registered-key',
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithPath: childPath,
+                },
+                walletPassphrase: passphrase,
+            })
+                .should.be.rejectedWith(src_1.SafeDerivedPublicKeyMismatchError);
+        });
+        it('decrypts child encryptedPrv as-is for wallet sharee (hardened child prv)', async function () {
+            const childPrv = 'child-level-prv';
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            const result = await wallet.getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'child-pub',
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithSeed: '123',
+                    encryptedPrv: `enc:${childPrv}`,
+                },
+                walletPassphrase: passphrase,
+            });
+            result.should.eql(childPrv);
+            keychainsGetStub.notCalled.should.be.true();
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('does not auto-populate coldDerivationSeed when explicit prv and encryptedPrv are present', async function () {
+            const childPrv = 'child-level-prv';
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            const result = await wallet.getUserPrv({
+                prv: childPrv,
+                keychain: {
+                    id: 'child-key',
+                    pub: 'child-pub',
+                    type: 'independent',
+                    parent: rootKeyId,
+                    derivedFromParentWithSeed: '123',
+                    encryptedPrv: `enc:${childPrv}`,
+                },
+            });
+            result.should.eql(childPrv);
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('still auto-populates coldDerivationSeed for SMC with params.prv and no encryptedPrv', async function () {
+            const wallet = makeWallet();
+            const result = await wallet.getUserPrv({
+                prv,
+                keychain: {
+                    id: 'smc-key',
+                    pub: 'smc-pub',
+                    type: 'independent',
+                    derivedFromParentWithSeed: '123',
+                },
+            });
+            result.should.eql(softDerivedPrv);
+            mockBaseCoin.deriveKeyWithSeed.calledOnce.should.be.true();
+        });
+        it('does not apply an explicit coldDerivationSeed after decrypting encryptedPrv', async function () {
+            const wallet = makeWallet();
+            const childPrv = prv;
+            const result = await wallet.getUserPrv({
+                keychain: {
+                    id: 'smc-key',
+                    pub: 'smc-pub',
+                    type: 'independent',
+                    encryptedPrv: `enc:${childPrv}`,
+                },
+                walletPassphrase: passphrase,
+                coldDerivationSeed: '123',
+            });
+            result.should.eql(childPrv);
+            mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();
+        });
+        it('throws encryptedPrv error before walletPassphrase when both are missing', async function () {
+            const wallet = makeWallet();
+            await wallet
+                .getUserPrv({
+                keychain: {
+                    id: 'child-key',
+                    pub: 'pub',
+                    type: 'independent',
+                },
+            })
+                .should.be.rejectedWith('keychain does not have property encryptedPrv');
+        });
+    });
+    describe('getEncryptedUserKeychain', function () {
+        it('still fails for a safe owner so wallet sharing cannot obtain root material', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.resolves({
+                id: 'user-key',
+                pub: 'child-pub',
+                type: 'independent',
+                parent: rootKeyId,
+                derivedFromParentWithSeed: '123',
+            });
+            await wallet.getEncryptedUserKeychain().should.be.rejectedWith(src_1.MissingEncryptedKeychainError);
+            keychainsGetStub.called.should.be.true();
+        });
+    });
+    describe('signing guards', function () {
+        it('getUserKeyAndSignTssTransaction allows safe child keychain without encryptedPrv', async function () {
+            const wallet = makeWallet({
+                safe: 'safe-id-1',
+                multisigType: 'tss',
+                type: 'hot',
+            });
+            const childKeychain = {
+                id: 'child-key',
+                pub: 'child-pub',
+                type: 'tss',
+                parent: rootKeyId,
+                commonKeychain: 'ck',
+            };
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            mockBaseCoin.keychains.returns({
+                get: keychainsGetStub,
+                getKeysForSigning: sinon.stub().resolves([childKeychain]),
+            });
+            const signStub = sinon.stub(src_1.Wallet.prototype, 'signTransaction').resolves({ txHex: 'signed' });
+            const result = await wallet.getUserKeyAndSignTssTransaction({
+                txRequestId: 'tx-req',
+                walletPassphrase: passphrase,
+            });
+            result.should.eql({ txHex: 'signed' });
+            signStub.calledOnce.should.be.true();
+            const signArgs = signStub.firstCall.args[0];
+            signArgs.keychain.should.eql(childKeychain);
+        });
+        it('getUserKeyAndSignTssTransaction rejects wrong passphrase early for safe child wallets', async function () {
+            const wallet = makeWallet({
+                safe: 'safe-id-1',
+                multisigType: 'tss',
+                type: 'hot',
+            });
+            const childKeychain = {
+                id: 'child-key',
+                pub: 'child-pub',
+                type: 'tss',
+                parent: rootKeyId,
+                commonKeychain: 'ck',
+            };
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            mockBaseCoin.keychains.returns({
+                get: keychainsGetStub,
+                getKeysForSigning: sinon.stub().resolves([childKeychain]),
+            });
+            const signStub = sinon.stub(src_1.Wallet.prototype, 'signTransaction');
+            await wallet
+                .getUserKeyAndSignTssTransaction({
+                txRequestId: 'tx-req',
+                walletPassphrase: 'wrong-passphrase',
+            })
+                .should.be.rejectedWith(src_1.IncorrectPasswordError);
+            signStub.notCalled.should.be.true();
+            keychainsGetStub.calledOnce.should.be.true();
+        });
+        it('signTransaction does not pass the root prv into TSS signing for a safe owner', async function () {
+            const wallet = makeWallet({
+                safe: 'safe-id-1',
+                multisigType: 'tss',
+                type: 'hot',
+            });
+            const childKeychain = {
+                id: 'child-key',
+                pub: 'child-pub',
+                type: 'tss',
+                parent: rootKeyId,
+                commonKeychain: 'ck',
+            };
+            keychainsGetStub.resolves({
+                id: rootKeyId,
+                source: 'user',
+                encryptedPrv: `enc:${prv}`,
+                type: 'independent',
+                pub: 'root-pub',
+            });
+            mockBaseCoin.keychains.returns({
+                get: keychainsGetStub,
+                getKeysForSigning: sinon.stub().resolves([childKeychain]),
+            });
+            mockBaseCoin.presignTransaction = sinon.stub().callsFake(async (params) => params);
+            mockBaseCoin.getMPCAlgorithm = sinon.stub().returns('eddsa');
+            const signTssStub = sinon.stub(src_1.Wallet.prototype, 'signTransactionTss').resolves({ txHex: 'signed' });
+            await wallet
+                .signTransaction({
+                walletPassphrase: passphrase,
+                txPrebuild: { txRequestId: 'tx-req' },
+            })
+                .should.be.rejectedWith(src_1.SafeOwnerSigningNotImplementedError);
+            signTssStub.notCalled.should.be.true();
+        });
+    });
+});
+describe('WCN-1200 recreateAndSignTSSTransaction safe path', function () {
+    afterEach(function () {
+        sinon.restore();
+    });
+    function makePendingApproval(wallet) {
+        const recreateTxRequest = sinon.stub().resolves({
+            apiVersion: 'lite',
+            txRequestId: 'tx-req',
+            unsignedTxs: [{ serializedTxHex: 'deadbeef', signableHex: 'ab', derivationPath: 'm/0' }],
+            transactions: [],
+        });
+        const pendingApproval = new src_1.PendingApproval({}, wallet.baseCoin, {
+            id: 'pa0',
+            txRequestId: 'tx-req',
+            info: { type: 'transactionRequest', transactionRequest: { recipients: [], coinSpecific: {} } },
+            state: 'pending',
+            creator: 'test',
+        }, wallet);
+        pendingApproval.tssUtils = { recreateTxRequest };
+        return { pendingApproval, recreateTxRequest };
+    }
+    it('uses getUserPrv for the safe owner (minter) instead of getPrv', async function () {
+        const childUserKeychain = {
+            id: 'child-key',
+            pub: 'child-pub',
+            type: 'tss',
+            parent: 'root-key-id',
+            derivedFromParentWithSeed: 'seed',
+        };
+        const getKeysForSigning = sinon.stub().resolves([childUserKeychain]);
+        const getUserPrv = sinon.stub().resolves('decryptedPrv');
+        const getPrv = sinon.stub().resolves('should-not-be-called');
+        const wallet = {
+            safeId: () => 'safe-id-1',
+            getUserPrv,
+            getPrv,
+            baseCoin: {
+                keychains: () => ({ getKeysForSigning }),
+                supportsTss: () => true,
+                getMPCAlgorithm: () => 'eddsa',
+            },
+            multisigTypeVersion: () => undefined,
+        };
+        const { pendingApproval, recreateTxRequest } = makePendingApproval(wallet);
+        const result = await pendingApproval.recreateAndSignTSSTransaction({ walletPassphrase: 'pass' }, new src_1.RequestTracer());
+        result.should.eql({ txHex: 'deadbeef' });
+        getPrv.notCalled.should.be.true();
+        getKeysForSigning.calledOnce.should.be.true();
+        getUserPrv
+            .calledOnceWithExactly({
+            keychain: childUserKeychain,
+            walletPassphrase: 'pass',
+        })
+            .should.be.true();
+        recreateTxRequest.calledOnce.should.be.true();
+    });
+    it('uses getPrv for a safe wallet sharee (child encryptedPrv already present)', async function () {
+        const childUserKeychain = {
+            id: 'child-key',
+            pub: 'child-pub',
+            type: 'tss',
+            parent: 'root-key-id',
+            derivedFromParentWithSeed: 'seed',
+            encryptedPrv: 'enc:sharee-prv',
+        };
+        const getKeysForSigning = sinon.stub().resolves([childUserKeychain]);
+        const getUserPrv = sinon.stub().resolves('should-not-be-called');
+        const getPrv = sinon.stub().resolves('sharee-prv');
+        const wallet = {
+            safeId: () => 'safe-id-1',
+            getUserPrv,
+            getPrv,
+            baseCoin: {
+                keychains: () => ({ getKeysForSigning }),
+                supportsTss: () => true,
+                getMPCAlgorithm: () => 'eddsa',
+            },
+            multisigTypeVersion: () => undefined,
+        };
+        const { pendingApproval, recreateTxRequest } = makePendingApproval(wallet);
+        const result = await pendingApproval.recreateAndSignTSSTransaction({ walletPassphrase: 'pass' }, new src_1.RequestTracer());
+        result.should.eql({ txHex: 'deadbeef' });
+        getUserPrv.notCalled.should.be.true();
+        getPrv.calledOnceWithExactly({ walletPassphrase: 'pass' }).should.be.true();
+        recreateTxRequest.calledOnce.should.be.true();
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeGetUserPrv.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/safeGetUserPrv.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport 'should';\nimport * as sinon from 'sinon';\nimport { bip32 } from '@bitgo-beta/utxo-lib';\nimport {\n  buildSafeBip44Path,\n  deriveSafeChildHardenedFromXprv,\n  fetchRootKeychainForSafeChild,\n  IncorrectPasswordError,\n  InvalidRootKeychainSourceError,\n  MissingEncryptedKeychainError,\n  PendingApproval,\n  RequestTracer,\n  SafeDerivedPublicKeyMismatchError,\n  SafeOwnerSigningNotImplementedError,\n  Wallet,\n} from '../../../../src';\nimport { BaseCoin } from '../../../../src/bitgo/baseCoin';\n\nrequire('should-sinon');\n\ndescribe('WCN-1200 safe child getUserPrv root-fetch detour', function () {\n  const prv =\n    'xprv9s21ZrQH143K3hekyNj7TciR4XNYe1kMj68W2ipjJGNHETWP7o42AjDnSPgKhdZ4x8NBAvaL72RrXjuXNdmkMqLERZza73oYugGtbLFXG8g';\n  const softDerivedNode = BaseCoin.deriveKeyWithSeedBip32(bip32.fromBase58(prv), '123');\n  if (!softDerivedNode.key.privateKey) {\n    throw new Error('expected deriveKeyWithSeedBip32 to return a private key');\n  }\n  const softDerivedPrv = softDerivedNode.key.toBase58();\n  const childPath = buildSafeBip44Path(0, 'secp256k1Multisig', 123);\n  const hardened = deriveSafeChildHardenedFromXprv(prv, childPath);\n  const passphrase = 'test-passphrase';\n  const rootKeyId = 'root-key-id';\n\n  let mockBitGo: any;\n  let mockBaseCoin: any;\n  let keychainsGetStub: sinon.SinonStub;\n  let encryptStub: sinon.SinonStub;\n  let decryptStub: sinon.SinonStub;\n\n  const baseWalletData = {\n    id: 'wallet-id',\n    coin: 'tbtc',\n    keys: ['user-key', 'backup-key', 'bitgo-key'],\n    type: 'hot',\n    multisigType: 'onchain',\n    enterprise: 'ent-id',\n  };\n\n  beforeEach(function () {\n    keychainsGetStub = sinon.stub();\n    encryptStub = sinon.stub();\n    decryptStub = sinon.stub();\n\n    mockBitGo = {\n      encrypt: encryptStub,\n      decrypt: decryptStub,\n      url: sinon.stub().returns('https://test.bitgo.com/'),\n      setRequestTracer: sinon.stub(),\n    };\n\n    mockBaseCoin = {\n      getChain: sinon.stub().returns('tbtc'),\n      getFamily: sinon.stub().returns('btc'),\n      getFullName: sinon.stub().returns('Test Bitcoin'),\n      keychains: sinon.stub().returns({\n        get: keychainsGetStub,\n        getKeysForSigning: sinon.stub().resolves([]),\n      }),\n      deriveKeyWithSeed: sinon.stub().callsFake(({ key, seed }: { key: string; seed: string }) => {\n        if (key === prv && seed === '123') {\n          return { key: softDerivedPrv, derivationPath: 'm/999999/...' };\n        }\n        return { key: `derived(${key},${seed})`, derivationPath: 'm/0' };\n      }),\n      url: sinon.stub().callsFake((path: string) => `https://test.bitgo.com/api/v2/tbtc${path}`),\n      supportsStaking: sinon.stub().returns(false),\n      supportsTss: sinon.stub().returns(false),\n      getMPCAlgorithm: sinon.stub(),\n      keyIdsForSigning: sinon.stub().returns([0, 1, 2]),\n    };\n\n    decryptStub.callsFake(({ input, password }: { input: string; password: string }) => {\n      if (password !== passphrase) {\n        return null;\n      }\n      if (typeof input === 'string' && input.startsWith('enc:')) {\n        return input.slice(4);\n      }\n      return null;\n    });\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  function makeWallet(overrides: Record<string, unknown> = {}): Wallet {\n    return new Wallet(mockBitGo, mockBaseCoin as unknown as BaseCoin, {\n      ...baseWalletData,\n      ...overrides,\n    });\n  }\n\n  describe('fetchRootKeychainForSafeChild', function () {\n    it('throws when child keychain has no parent', async function () {\n      await fetchRootKeychainForSafeChild(mockBaseCoin.keychains(), {\n        id: 'child-key',\n        type: 'independent',\n        pub: 'child-pub',\n      }).should.be.rejectedWith('childKeychain.parent is required to fetch the root keychain');\n      keychainsGetStub.notCalled.should.be.true();\n    });\n\n    it('throws InvalidRootKeychainSourceError when root source is backup', async function () {\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'backup',\n        encryptedPrv: 'enc:root',\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      await fetchRootKeychainForSafeChild(mockBaseCoin.keychains(), {\n        id: 'child-key',\n        parent: rootKeyId,\n        type: 'independent',\n        pub: 'child-pub',\n      }).should.be.rejectedWith(InvalidRootKeychainSourceError);\n    });\n\n    it('returns the root keychain when source is user', async function () {\n      const root = {\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: 'enc:root',\n        type: 'independent',\n        pub: 'root-pub',\n      };\n      keychainsGetStub.resolves(root);\n\n      const result = await fetchRootKeychainForSafeChild(mockBaseCoin.keychains(), {\n        id: 'child-key',\n        parent: rootKeyId,\n        type: 'independent',\n        pub: 'child-pub',\n      });\n      result.should.eql(root);\n    });\n\n    it('throws when root keychain has no encryptedPrv', async function () {\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      await fetchRootKeychainForSafeChild(mockBaseCoin.keychains(), {\n        id: 'child-key',\n        parent: rootKeyId,\n        type: 'independent',\n        pub: 'child-pub',\n      }).should.be.rejectedWith(/does not have property encryptedPrv/);\n    });\n  });\n\n  describe('getUserPrv', function () {\n    it('throws when keychain has no encryptedPrv on a non-safe wallet', async function () {\n      const wallet = makeWallet();\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'pub',\n            type: 'independent',\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith('keychain does not have property encryptedPrv');\n    });\n\n    it('throws for a non-safe wallet even when keychain has parent', async function () {\n      const wallet = makeWallet();\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'pub',\n            type: 'independent',\n            parent: rootKeyId,\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith('keychain does not have property encryptedPrv');\n      keychainsGetStub.notCalled.should.be.true();\n    });\n\n    it('throws for a safe wallet when keychain has no parent', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'pub',\n            type: 'independent',\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith('keychain does not have property encryptedPrv');\n      keychainsGetStub.notCalled.should.be.true();\n    });\n\n    it('fetches root and hardened-derives child key for safe owner', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      const result = await wallet.getUserPrv({\n        keychain: {\n          id: 'child-key',\n          pub: hardened.pub,\n          type: 'independent',\n          parent: rootKeyId,\n          derivedFromParentWithPath: childPath,\n        },\n        walletPassphrase: passphrase,\n      });\n\n      result.should.eql(hardened.prv);\n      result.should.not.eql(softDerivedPrv);\n      keychainsGetStub.calledOnceWithExactly({ id: rootKeyId }).should.be.true();\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('requires derivedFromParentWithPath on the child keychain', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: hardened.pub,\n            type: 'independent',\n            parent: rootKeyId,\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith(/missing derivedFromParentWithPath/);\n    });\n\n    it('fails closed when derivedFromParentWithPath does not match the registered pub', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: hardened.pub,\n            type: 'independent',\n            parent: rootKeyId,\n            derivedFromParentWithPath: \"m/44'/0'/1'/0'\",\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith(SafeDerivedPublicKeyMismatchError);\n    });\n\n    for (const storedPath of [\"not-a-path'\", \"m/123'\", 'm/44/0/1/123']) {\n      it(`rejects a non-BIP44 derivedFromParentWithPath ${JSON.stringify(storedPath)}`, async function () {\n        const wallet = makeWallet({ safe: 'safe-id-1' });\n        keychainsGetStub.resolves({\n          id: rootKeyId,\n          source: 'user',\n          encryptedPrv: `enc:${prv}`,\n          type: 'independent',\n          pub: 'root-pub',\n        });\n\n        await wallet\n          .getUserPrv({\n            keychain: {\n              id: 'child-key',\n              pub: hardened.pub,\n              type: 'independent',\n              parent: rootKeyId,\n              derivedFromParentWithPath: storedPath,\n            },\n            walletPassphrase: passphrase,\n          })\n          .should.be.rejectedWith(/derivedFromParentWithPath/);\n      });\n    }\n\n    it('fails closed for TSS safe owner instead of returning the root prv', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });\n\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'unrelated-child-pub',\n            type: 'tss',\n            parent: rootKeyId,\n            derivedFromParentWithSeed: '123',\n            commonKeychain: 'ck',\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith(SafeOwnerSigningNotImplementedError);\n      keychainsGetStub.notCalled.should.be.true();\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('fails closed for ed25519 onchain safe owner instead of BIP32-deriving', async function () {\n      mockBaseCoin.getFamily.returns('xlm');\n      const wallet = makeWallet({ safe: 'safe-id-1', coin: 'txlm' });\n\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'child-pub',\n            type: 'independent',\n            parent: rootKeyId,\n            derivedFromParentWithSeed: '123',\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith(SafeOwnerSigningNotImplementedError);\n      keychainsGetStub.notCalled.should.be.true();\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('aborts locally when derived pub does not match registered child pub', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'xpub-wrong-registered-key',\n            type: 'independent',\n            parent: rootKeyId,\n            derivedFromParentWithPath: childPath,\n          },\n          walletPassphrase: passphrase,\n        })\n        .should.be.rejectedWith(SafeDerivedPublicKeyMismatchError);\n    });\n\n    it('decrypts child encryptedPrv as-is for wallet sharee (hardened child prv)', async function () {\n      const childPrv = 'child-level-prv';\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n\n      const result = await wallet.getUserPrv({\n        keychain: {\n          id: 'child-key',\n          pub: 'child-pub',\n          type: 'independent',\n          parent: rootKeyId,\n          derivedFromParentWithSeed: '123',\n          encryptedPrv: `enc:${childPrv}`,\n        },\n        walletPassphrase: passphrase,\n      });\n\n      result.should.eql(childPrv);\n      keychainsGetStub.notCalled.should.be.true();\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('does not auto-populate coldDerivationSeed when explicit prv and encryptedPrv are present', async function () {\n      const childPrv = 'child-level-prv';\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n\n      const result = await wallet.getUserPrv({\n        prv: childPrv,\n        keychain: {\n          id: 'child-key',\n          pub: 'child-pub',\n          type: 'independent',\n          parent: rootKeyId,\n          derivedFromParentWithSeed: '123',\n          encryptedPrv: `enc:${childPrv}`,\n        },\n      });\n\n      result.should.eql(childPrv);\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('still auto-populates coldDerivationSeed for SMC with params.prv and no encryptedPrv', async function () {\n      const wallet = makeWallet();\n\n      const result = await wallet.getUserPrv({\n        prv,\n        keychain: {\n          id: 'smc-key',\n          pub: 'smc-pub',\n          type: 'independent',\n          derivedFromParentWithSeed: '123',\n        },\n      });\n\n      result.should.eql(softDerivedPrv);\n      mockBaseCoin.deriveKeyWithSeed.calledOnce.should.be.true();\n    });\n\n    it('does not apply an explicit coldDerivationSeed after decrypting encryptedPrv', async function () {\n      const wallet = makeWallet();\n      const childPrv = prv;\n\n      const result = await wallet.getUserPrv({\n        keychain: {\n          id: 'smc-key',\n          pub: 'smc-pub',\n          type: 'independent',\n          encryptedPrv: `enc:${childPrv}`,\n        },\n        walletPassphrase: passphrase,\n        coldDerivationSeed: '123',\n      });\n\n      result.should.eql(childPrv);\n      mockBaseCoin.deriveKeyWithSeed.notCalled.should.be.true();\n    });\n\n    it('throws encryptedPrv error before walletPassphrase when both are missing', async function () {\n      const wallet = makeWallet();\n      await wallet\n        .getUserPrv({\n          keychain: {\n            id: 'child-key',\n            pub: 'pub',\n            type: 'independent',\n          },\n        })\n        .should.be.rejectedWith('keychain does not have property encryptedPrv');\n    });\n  });\n\n  describe('getEncryptedUserKeychain', function () {\n    it('still fails for a safe owner so wallet sharing cannot obtain root material', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.resolves({\n        id: 'user-key',\n        pub: 'child-pub',\n        type: 'independent',\n        parent: rootKeyId,\n        derivedFromParentWithSeed: '123',\n      });\n\n      await wallet.getEncryptedUserKeychain().should.be.rejectedWith(MissingEncryptedKeychainError);\n      keychainsGetStub.called.should.be.true();\n    });\n  });\n\n  describe('signing guards', function () {\n    it('getUserKeyAndSignTssTransaction allows safe child keychain without encryptedPrv', async function () {\n      const wallet = makeWallet({\n        safe: 'safe-id-1',\n        multisigType: 'tss',\n        type: 'hot',\n      });\n      const childKeychain = {\n        id: 'child-key',\n        pub: 'child-pub',\n        type: 'tss' as const,\n        parent: rootKeyId,\n        commonKeychain: 'ck',\n      };\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n      mockBaseCoin.keychains.returns({\n        get: keychainsGetStub,\n        getKeysForSigning: sinon.stub().resolves([childKeychain]),\n      });\n      const signStub = sinon.stub(Wallet.prototype, 'signTransaction').resolves({ txHex: 'signed' } as any);\n\n      const result = await wallet.getUserKeyAndSignTssTransaction({\n        txRequestId: 'tx-req',\n        walletPassphrase: passphrase,\n      });\n\n      result.should.eql({ txHex: 'signed' });\n      signStub.calledOnce.should.be.true();\n      const signArgs = signStub.firstCall.args[0] as { keychain: typeof childKeychain };\n      signArgs.keychain.should.eql(childKeychain);\n    });\n\n    it('getUserKeyAndSignTssTransaction rejects wrong passphrase early for safe child wallets', async function () {\n      const wallet = makeWallet({\n        safe: 'safe-id-1',\n        multisigType: 'tss',\n        type: 'hot',\n      });\n      const childKeychain = {\n        id: 'child-key',\n        pub: 'child-pub',\n        type: 'tss' as const,\n        parent: rootKeyId,\n        commonKeychain: 'ck',\n      };\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n      mockBaseCoin.keychains.returns({\n        get: keychainsGetStub,\n        getKeysForSigning: sinon.stub().resolves([childKeychain]),\n      });\n      const signStub = sinon.stub(Wallet.prototype, 'signTransaction');\n\n      await wallet\n        .getUserKeyAndSignTssTransaction({\n          txRequestId: 'tx-req',\n          walletPassphrase: 'wrong-passphrase',\n        })\n        .should.be.rejectedWith(IncorrectPasswordError);\n\n      signStub.notCalled.should.be.true();\n      keychainsGetStub.calledOnce.should.be.true();\n    });\n\n    it('signTransaction does not pass the root prv into TSS signing for a safe owner', async function () {\n      const wallet = makeWallet({\n        safe: 'safe-id-1',\n        multisigType: 'tss',\n        type: 'hot',\n      });\n      const childKeychain = {\n        id: 'child-key',\n        pub: 'child-pub',\n        type: 'tss' as const,\n        parent: rootKeyId,\n        commonKeychain: 'ck',\n      };\n      keychainsGetStub.resolves({\n        id: rootKeyId,\n        source: 'user',\n        encryptedPrv: `enc:${prv}`,\n        type: 'independent',\n        pub: 'root-pub',\n      });\n      mockBaseCoin.keychains.returns({\n        get: keychainsGetStub,\n        getKeysForSigning: sinon.stub().resolves([childKeychain]),\n      });\n      mockBaseCoin.presignTransaction = sinon.stub().callsFake(async (params: any) => params);\n      mockBaseCoin.getMPCAlgorithm = sinon.stub().returns('eddsa');\n      const signTssStub = sinon.stub(Wallet.prototype as any, 'signTransactionTss').resolves({ txHex: 'signed' });\n\n      await wallet\n        .signTransaction({\n          walletPassphrase: passphrase,\n          txPrebuild: { txRequestId: 'tx-req' },\n        })\n        .should.be.rejectedWith(SafeOwnerSigningNotImplementedError);\n      signTssStub.notCalled.should.be.true();\n    });\n  });\n});\n\ndescribe('WCN-1200 recreateAndSignTSSTransaction safe path', function () {\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  function makePendingApproval(wallet: any) {\n    const recreateTxRequest = sinon.stub().resolves({\n      apiVersion: 'lite',\n      txRequestId: 'tx-req',\n      unsignedTxs: [{ serializedTxHex: 'deadbeef', signableHex: 'ab', derivationPath: 'm/0' }],\n      transactions: [],\n    });\n    const pendingApproval = new PendingApproval(\n      {} as any,\n      wallet.baseCoin,\n      {\n        id: 'pa0',\n        txRequestId: 'tx-req',\n        info: { type: 'transactionRequest', transactionRequest: { recipients: [], coinSpecific: {} } },\n        state: 'pending',\n        creator: 'test',\n      } as any,\n      wallet\n    );\n    (pendingApproval as any).tssUtils = { recreateTxRequest };\n    return { pendingApproval, recreateTxRequest };\n  }\n\n  it('uses getUserPrv for the safe owner (minter) instead of getPrv', async function () {\n    const childUserKeychain = {\n      id: 'child-key',\n      pub: 'child-pub',\n      type: 'tss',\n      parent: 'root-key-id',\n      derivedFromParentWithSeed: 'seed',\n    };\n    const getKeysForSigning = sinon.stub().resolves([childUserKeychain]);\n    const getUserPrv = sinon.stub().resolves('decryptedPrv');\n    const getPrv = sinon.stub().resolves('should-not-be-called');\n    const wallet: any = {\n      safeId: () => 'safe-id-1',\n      getUserPrv,\n      getPrv,\n      baseCoin: {\n        keychains: () => ({ getKeysForSigning }),\n        supportsTss: () => true,\n        getMPCAlgorithm: () => 'eddsa',\n      },\n      multisigTypeVersion: () => undefined,\n    };\n    const { pendingApproval, recreateTxRequest } = makePendingApproval(wallet);\n\n    const result = await pendingApproval.recreateAndSignTSSTransaction(\n      { walletPassphrase: 'pass' },\n      new RequestTracer()\n    );\n\n    result.should.eql({ txHex: 'deadbeef' });\n    getPrv.notCalled.should.be.true();\n    getKeysForSigning.calledOnce.should.be.true();\n    getUserPrv\n      .calledOnceWithExactly({\n        keychain: childUserKeychain,\n        walletPassphrase: 'pass',\n      })\n      .should.be.true();\n    recreateTxRequest.calledOnce.should.be.true();\n  });\n\n  it('uses getPrv for a safe wallet sharee (child encryptedPrv already present)', async function () {\n    const childUserKeychain = {\n      id: 'child-key',\n      pub: 'child-pub',\n      type: 'tss',\n      parent: 'root-key-id',\n      derivedFromParentWithSeed: 'seed',\n      encryptedPrv: 'enc:sharee-prv',\n    };\n    const getKeysForSigning = sinon.stub().resolves([childUserKeychain]);\n    const getUserPrv = sinon.stub().resolves('should-not-be-called');\n    const getPrv = sinon.stub().resolves('sharee-prv');\n    const wallet: any = {\n      safeId: () => 'safe-id-1',\n      getUserPrv,\n      getPrv,\n      baseCoin: {\n        keychains: () => ({ getKeysForSigning }),\n        supportsTss: () => true,\n        getMPCAlgorithm: () => 'eddsa',\n      },\n      multisigTypeVersion: () => undefined,\n    };\n    const { pendingApproval, recreateTxRequest } = makePendingApproval(wallet);\n\n    const result = await pendingApproval.recreateAndSignTSSTransaction(\n      { walletPassphrase: 'pass' },\n      new RequestTracer()\n    );\n\n    result.should.eql({ txHex: 'deadbeef' });\n    getUserPrv.notCalled.should.be.true();\n    getPrv.calledOnceWithExactly({ walletPassphrase: 'pass' }).should.be.true();\n    recreateTxRequest.calledOnce.should.be.true();\n  });\n});\n"]}