@bitgo/sdk-core 38.13.0 → 38.15.0

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

@@ -0,0 +1,303 @@
+"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
+ *
+ * Safe-wallet SPEND sharing. Mirrors test/unit/bitgo/wallet/safeGetUserPrv.ts (sinon-stubbed,
+ * no nock) for the sharing analogue: a safe owner's children are pub-only, so the share path
+ * must re-derive the child prv from the root — never the root material.
+ */
+require("should");
+const sinon = __importStar(require("sinon"));
+const src_1 = require("../../../../src");
+const ecdh_1 = require("../../../../src/bitgo/ecdh");
+const bitcoin_1 = require("../../../../src/bitgo/bitcoin");
+require('should-sinon');
+describe('Safe wallet spend sharing', function () {
+    const prv = 'xprv9s21ZrQH143K3hekyNj7TciR4XNYe1kMj68W2ipjJGNHETWP7o42AjDnSPgKhdZ4x8NBAvaL72RrXjuXNdmkMqLERZza73oYugGtbLFXG8g';
+    const hardened = (0, src_1.deriveSafeChildHardenedFromXprv)(prv, '123');
+    const passphrase = 'test-passphrase';
+    const rootKeyId = 'root-key-id';
+    const SHAREE_PUB = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
+    let mockBitGo;
+    let mockBaseCoin;
+    let keychainsGetStub;
+    let encryptStub;
+    let decryptStub;
+    let createShareStub;
+    let createBulkKeySharesStub;
+    const baseWalletData = {
+        id: 'wallet-id',
+        coin: 'tbtc',
+        keys: ['user-key', 'backup-key', 'bitgo-key'],
+        type: 'hot',
+        multisigType: 'onchain',
+        enterprise: 'ent-id',
+    };
+    const childKeychain = (id) => ({
+        id,
+        pub: hardened.pub,
+        type: 'independent',
+        parent: rootKeyId,
+        derivedFromParentWithPath: "m/123'",
+    });
+    const publicOnlyKeychain = (id) => ({ id, pub: 'pub-' + id, type: 'independent' });
+    const rootKeychain = {
+        id: rootKeyId,
+        source: 'user',
+        encryptedPrv: `enc:${prv}`,
+        type: 'independent',
+        pub: 'root-pub',
+    };
+    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(),
+            getSharingKey: sinon.stub().resolves({ userId: 'sharee-id', pubkey: SHAREE_PUB, path: 'm/0' }),
+        };
+        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(),
+            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]),
+        };
+        keychainsGetStub.callsFake(({ id }) => Promise.resolve(id === rootKeyId ? rootKeychain : id === 'user-key' ? childKeychain(id) : publicOnlyKeychain(id)));
+        // Reversible encrypt: `shared:<password>:<input>` so tests can verify the ECDH secret and
+        // that the payload encrypts the CHILD prv, not the root.
+        encryptStub.callsFake(({ input, password }) => Promise.resolve(`shared:${password}:${input}`));
+        decryptStub.callsFake(({ input, password }) => {
+            if (password !== passphrase)
+                return null;
+            if (typeof input === 'string' && input.startsWith('enc:'))
+                return input.slice(4);
+            return null;
+        });
+        createShareStub = sinon.stub(src_1.Wallet.prototype, 'createShare').resolves({});
+        createBulkKeySharesStub = sinon.stub(src_1.Wallet.prototype, 'createBulkKeyShares').resolves({ shares: [] });
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    function makeWallet(overrides = {}) {
+        return new src_1.Wallet(mockBitGo, mockBaseCoin, {
+            ...baseWalletData,
+            ...overrides,
+        });
+    }
+    async function getShareOptions(wallet, params = {}) {
+        await wallet.shareWallet({
+            email: 'shareto@test.com',
+            permissions: 'spend',
+            walletPassphrase: passphrase,
+            ...params,
+        });
+        return createShareStub.firstCall.args[0];
+    }
+    describe('hot safe wallet, spend share', function () {
+        it('derives child material, uses the registered child pub, and never ships root material', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            const options = await getShareOptions(wallet);
+            options.skipKeychain.should.equal(false);
+            options.keychain.should.be.ok();
+            options.keychain.pub.should.equal(hardened.pub);
+            const json = JSON.stringify(options.keychain);
+            json.should.not.containEql(prv); // root xprv never leaves
+            json.should.not.containEql('root-pub'); // root pub never leaves
+        });
+        it('the encrypted prv ECDH-decrypts (sharee side) to the CHILD prv', async function () {
+            const shareeKey = (0, bitcoin_1.makeRandomKey)();
+            const shareePub = shareeKey.publicKey.toString('hex');
+            mockBitGo.getSharingKey = sinon.stub().resolves({ userId: 'sharee-id', pubkey: shareePub, path: 'm/0' });
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            const options = await getShareOptions(wallet);
+            const shareeSecret = (0, ecdh_1.getSharedSecret)(shareeKey, Buffer.from(options.keychain.fromPubKey, 'hex')).toString('hex');
+            options.keychain.encryptedPrv.should.equal(`shared:${shareeSecret}:${hardened.prv}`);
+        });
+        it('a view-only share needs no keychain and does not fetch the root', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            await wallet.shareWallet({ email: 'shareto@test.com', permissions: 'view', walletPassphrase: passphrase });
+            createShareStub.firstCall.args[0].skipKeychain.should.equal(true);
+            createShareStub.firstCall.args[0].should.have.property('keychain', undefined);
+            keychainsGetStub.notCalled.should.equal(true);
+        });
+        it('a wrong passphrase rejects with IncorrectPasswordError and posts nothing', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: 'wrong-passphrase' })
+                .should.be.rejectedWith(src_1.IncorrectPasswordError);
+            createShareStub.notCalled.should.equal(true);
+        });
+        it('a missing passphrase throws instead of silently skipKeychain', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend' })
+                .should.be.rejectedWith(/Missing walletPassphrase argument/);
+            createShareStub.notCalled.should.equal(true);
+        });
+        it('fails closed when the derived pub does not match the registered child pub', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.callsFake(({ id }) => Promise.resolve(id === rootKeyId
+                ? rootKeychain
+                : id === 'user-key'
+                    ? { ...childKeychain(id), pub: 'wrong-child-pub', derivedFromParentWithPath: "m/123'" }
+                    : publicOnlyKeychain(id)));
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })
+                .should.be.rejectedWith(src_1.SafeDerivedPublicKeyMismatchError);
+        });
+    });
+    describe('unsupported safe slots', function () {
+        it('TSS safe wallet throws SafeShareNotImplementedError without fetching the root', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })
+                .should.be.rejectedWith(src_1.SafeShareNotImplementedError);
+            // child fetched (safe branch), root never fetched (guard fires first)
+            keychainsGetStub.calledOnce.should.equal(true);
+            keychainsGetStub.firstCall.args[0].should.deepEqual({ id: 'user-key' });
+        });
+        it('ed25519 onchain safe wallet throws SafeShareNotImplementedError', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1', coin: 'txlm' });
+            mockBaseCoin.getFamily.returns('xlm');
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })
+                .should.be.rejectedWith(src_1.SafeShareNotImplementedError);
+            keychainsGetStub.calledOnce.should.equal(true);
+        });
+    });
+    describe('regression: non-safe and sharee paths', function () {
+        it('a genuine cold wallet still yields skipKeychain', async function () {
+            const wallet = makeWallet({ type: 'cold' });
+            const options = await getShareOptions(wallet);
+            options.skipKeychain.should.equal(true);
+            options.should.have.property('keychain', undefined);
+        });
+        it('a sharee re-sharing (child has encryptedPrv) takes the ordinary path and never fetches the root', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            const shareeChild = {
+                id: 'user-key',
+                pub: 'sharee-pub',
+                type: 'independent',
+                encryptedPrv: `enc:sharee-prv`,
+            };
+            keychainsGetStub.callsFake(({ id }) => Promise.resolve(id === 'user-key' ? shareeChild : publicOnlyKeychain(id)));
+            const options = await getShareOptions(wallet);
+            options.skipKeychain.should.equal(false);
+            options.keychain.pub.should.equal('sharee-pub');
+            // root (safe-owner detour) must never be reached for a sharee with an encrypted child prv
+            keychainsGetStub
+                .getCalls()
+                .filter((c) => c.args?.[0]?.id === rootKeyId)
+                .length.should.equal(0);
+        });
+        it('a malformed safe wallet (child with no parent) fails closed instead of cold-skipping', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            keychainsGetStub.callsFake(({ id }) => Promise.resolve(id === 'user-key' ? publicOnlyKeychain(id) : publicOnlyKeychain(id)));
+            await wallet
+                .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })
+                .should.be.rejectedWith(/safe child could not be resolved/);
+            createShareStub.notCalled.should.equal(true);
+        });
+        it('a non-safe hot wallet spend share is unchanged', async function () {
+            const wallet = makeWallet({});
+            const userKeychain = {
+                id: 'user-key',
+                pub: 'hot-pub',
+                type: 'independent',
+                encryptedPrv: `enc:hot-prv`,
+            };
+            keychainsGetStub.callsFake(({ id }) => Promise.resolve(id === 'user-key' ? userKeychain : publicOnlyKeychain(id)));
+            const options = await getShareOptions(wallet);
+            options.skipKeychain.should.equal(false);
+            options.keychain.pub.should.equal('hot-pub');
+        });
+        it('an lnbtc wallet takes the userAuth path and never enters the safe branch', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1', coin: 'lbtc' });
+            mockBaseCoin.getFamily.returns('lnbtc');
+            const safeChildSpy = sinon.spy(wallet, 'getSafeOwnerChildKeychain');
+            // stubbing the private keychain fetch so lnbtc resolves a keychain without full lightning mocks
+            sinon.stub(wallet, 'getEncryptedWalletKeychainForWalletSharing').resolves({
+                id: 'user-key',
+                pub: 'ln-pub',
+                encryptedPrv: `enc:ln-prv`,
+                type: 'independent',
+            });
+            const options = await getShareOptions(wallet);
+            options.keychain.pub.should.equal('ln-pub');
+            safeChildSpy.notCalled.should.equal(true);
+        });
+    });
+    describe('createBulkWalletShare on a safe wallet', function () {
+        const bulkParams = {
+            walletPassphrase: passphrase,
+            keyShareOptions: [
+                { userId: 'u1', pubKey: SHAREE_PUB, path: 'm/0', permissions: 'spend' },
+                { userId: 'u2', pubKey: SHAREE_PUB, path: 'm/0', permissions: 'spend' },
+            ],
+        };
+        it('derives the child once (one root decrypt) and fans it out per user', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1' });
+            await wallet.createBulkWalletShare(bulkParams);
+            createBulkKeySharesStub.calledOnce.should.equal(true);
+            const options = createBulkKeySharesStub.firstCall.args[0];
+            options.length.should.equal(2);
+            options.forEach((o) => o.keychain.pub.should.equal(hardened.pub));
+            // child + root exactly once (single root decrypt)
+            const rootCalls = keychainsGetStub.getCalls().filter((c) => c.args?.[0]?.id === rootKeyId);
+            rootCalls.length.should.equal(1);
+        });
+        it('the real error propagates instead of shareOptions cannot be empty', async function () {
+            const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });
+            await wallet.createBulkWalletShare(bulkParams).should.be.rejectedWith(src_1.SafeShareNotImplementedError);
+            createBulkKeySharesStub.notCalled.should.equal(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safeShareWallet.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/wallet/safeShareWallet.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n *\n * Safe-wallet SPEND sharing. Mirrors test/unit/bitgo/wallet/safeGetUserPrv.ts (sinon-stubbed,\n * no nock) for the sharing analogue: a safe owner's children are pub-only, so the share path\n * must re-derive the child prv from the root — never the root material.\n */\nimport 'should';\nimport * as sinon from 'sinon';\nimport {\n  IncorrectPasswordError,\n  SafeDerivedPublicKeyMismatchError,\n  SafeShareNotImplementedError,\n  Wallet,\n  deriveSafeChildHardenedFromXprv,\n} from '../../../../src';\nimport { BaseCoin } from '../../../../src/bitgo/baseCoin';\nimport { getSharedSecret } from '../../../../src/bitgo/ecdh';\nimport { makeRandomKey } from '../../../../src/bitgo/bitcoin';\n\nrequire('should-sinon');\n\ndescribe('Safe wallet spend sharing', function () {\n  const prv =\n    'xprv9s21ZrQH143K3hekyNj7TciR4XNYe1kMj68W2ipjJGNHETWP7o42AjDnSPgKhdZ4x8NBAvaL72RrXjuXNdmkMqLERZza73oYugGtbLFXG8g';\n  const hardened = deriveSafeChildHardenedFromXprv(prv, '123');\n  const passphrase = 'test-passphrase';\n  const rootKeyId = 'root-key-id';\n  const SHAREE_PUB = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';\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  let createShareStub: sinon.SinonStub;\n  let createBulkKeySharesStub: 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  const childKeychain = (id: string) => ({\n    id,\n    pub: hardened.pub,\n    type: 'independent' as const,\n    parent: rootKeyId,\n    derivedFromParentWithPath: \"m/123'\",\n  });\n  const publicOnlyKeychain = (id: string) => ({ id, pub: 'pub-' + id, type: 'independent' as const });\n  const rootKeychain = {\n    id: rootKeyId,\n    source: 'user' as const,\n    encryptedPrv: `enc:${prv}`,\n    type: 'independent' as const,\n    pub: 'root-pub',\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      getSharingKey: sinon.stub().resolves({ userId: 'sharee-id', pubkey: SHAREE_PUB, path: 'm/0' }),\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(),\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    keychainsGetStub.callsFake(({ id }: { id: string }) =>\n      Promise.resolve(id === rootKeyId ? rootKeychain : id === 'user-key' ? childKeychain(id) : publicOnlyKeychain(id))\n    );\n\n    // Reversible encrypt: `shared:<password>:<input>` so tests can verify the ECDH secret and\n    // that the payload encrypts the CHILD prv, not the root.\n    encryptStub.callsFake(({ input, password }: { input: string; password: string }) =>\n      Promise.resolve(`shared:${password}:${input}`)\n    );\n\n    decryptStub.callsFake(({ input, password }: { input: string; password: string }) => {\n      if (password !== passphrase) return null;\n      if (typeof input === 'string' && input.startsWith('enc:')) return input.slice(4);\n      return null;\n    });\n\n    createShareStub = sinon.stub(Wallet.prototype, 'createShare').resolves({});\n    createBulkKeySharesStub = sinon.stub(Wallet.prototype, 'createBulkKeyShares').resolves({ shares: [] });\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  async function getShareOptions(wallet: Wallet, params: Record<string, unknown> = {}) {\n    await wallet.shareWallet({\n      email: 'shareto@test.com',\n      permissions: 'spend',\n      walletPassphrase: passphrase,\n      ...params,\n    });\n    return createShareStub.firstCall.args[0];\n  }\n\n  describe('hot safe wallet, spend share', function () {\n    it('derives child material, uses the registered child pub, and never ships root material', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      const options = await getShareOptions(wallet);\n\n      options.skipKeychain.should.equal(false);\n      options.keychain.should.be.ok();\n      options.keychain.pub.should.equal(hardened.pub);\n\n      const json = JSON.stringify(options.keychain);\n      json.should.not.containEql(prv); // root xprv never leaves\n      json.should.not.containEql('root-pub'); // root pub never leaves\n    });\n\n    it('the encrypted prv ECDH-decrypts (sharee side) to the CHILD prv', async function () {\n      const shareeKey = makeRandomKey();\n      const shareePub = shareeKey.publicKey.toString('hex');\n      mockBitGo.getSharingKey = sinon.stub().resolves({ userId: 'sharee-id', pubkey: shareePub, path: 'm/0' });\n\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      const options = await getShareOptions(wallet);\n\n      const shareeSecret = getSharedSecret(shareeKey, Buffer.from(options.keychain.fromPubKey, 'hex')).toString('hex');\n      options.keychain.encryptedPrv.should.equal(`shared:${shareeSecret}:${hardened.prv}`);\n    });\n\n    it('a view-only share needs no keychain and does not fetch the root', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      await wallet.shareWallet({ email: 'shareto@test.com', permissions: 'view', walletPassphrase: passphrase });\n\n      createShareStub.firstCall.args[0].skipKeychain.should.equal(true);\n      createShareStub.firstCall.args[0].should.have.property('keychain', undefined);\n      keychainsGetStub.notCalled.should.equal(true);\n    });\n\n    it('a wrong passphrase rejects with IncorrectPasswordError and posts nothing', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: 'wrong-passphrase' })\n        .should.be.rejectedWith(IncorrectPasswordError);\n      createShareStub.notCalled.should.equal(true);\n    });\n\n    it('a missing passphrase throws instead of silently skipKeychain', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend' })\n        .should.be.rejectedWith(/Missing walletPassphrase argument/);\n      createShareStub.notCalled.should.equal(true);\n    });\n\n    it('fails closed when the derived pub does not match the registered child pub', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.callsFake(({ id }: { id: string }) =>\n        Promise.resolve(\n          id === rootKeyId\n            ? rootKeychain\n            : id === 'user-key'\n            ? { ...childKeychain(id), pub: 'wrong-child-pub', derivedFromParentWithPath: \"m/123'\" }\n            : publicOnlyKeychain(id)\n        )\n      );\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })\n        .should.be.rejectedWith(SafeDerivedPublicKeyMismatchError);\n    });\n  });\n\n  describe('unsupported safe slots', function () {\n    it('TSS safe wallet throws SafeShareNotImplementedError without fetching the root', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })\n        .should.be.rejectedWith(SafeShareNotImplementedError);\n      // child fetched (safe branch), root never fetched (guard fires first)\n      keychainsGetStub.calledOnce.should.equal(true);\n      keychainsGetStub.firstCall.args[0].should.deepEqual({ id: 'user-key' });\n    });\n\n    it('ed25519 onchain safe wallet throws SafeShareNotImplementedError', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1', coin: 'txlm' });\n      mockBaseCoin.getFamily.returns('xlm');\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })\n        .should.be.rejectedWith(SafeShareNotImplementedError);\n      keychainsGetStub.calledOnce.should.equal(true);\n    });\n  });\n\n  describe('regression: non-safe and sharee paths', function () {\n    it('a genuine cold wallet still yields skipKeychain', async function () {\n      const wallet = makeWallet({ type: 'cold' });\n      const options = await getShareOptions(wallet);\n      options.skipKeychain.should.equal(true);\n      options.should.have.property('keychain', undefined);\n    });\n\n    it('a sharee re-sharing (child has encryptedPrv) takes the ordinary path and never fetches the root', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      const shareeChild = {\n        id: 'user-key',\n        pub: 'sharee-pub',\n        type: 'independent' as const,\n        encryptedPrv: `enc:sharee-prv`,\n      };\n      keychainsGetStub.callsFake(({ id }: { id: string }) =>\n        Promise.resolve(id === 'user-key' ? shareeChild : publicOnlyKeychain(id))\n      );\n      const options = await getShareOptions(wallet);\n      options.skipKeychain.should.equal(false);\n      options.keychain.pub.should.equal('sharee-pub');\n      // root (safe-owner detour) must never be reached for a sharee with an encrypted child prv\n      keychainsGetStub\n        .getCalls()\n        .filter((c) => c.args?.[0]?.id === rootKeyId)\n        .length.should.equal(0);\n    });\n\n    it('a malformed safe wallet (child with no parent) fails closed instead of cold-skipping', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      keychainsGetStub.callsFake(({ id }: { id: string }) =>\n        Promise.resolve(id === 'user-key' ? publicOnlyKeychain(id) : publicOnlyKeychain(id))\n      );\n      await wallet\n        .shareWallet({ email: 'shareto@test.com', permissions: 'spend', walletPassphrase: passphrase })\n        .should.be.rejectedWith(/safe child could not be resolved/);\n      createShareStub.notCalled.should.equal(true);\n    });\n\n    it('a non-safe hot wallet spend share is unchanged', async function () {\n      const wallet = makeWallet({});\n      const userKeychain = {\n        id: 'user-key',\n        pub: 'hot-pub',\n        type: 'independent' as const,\n        encryptedPrv: `enc:hot-prv`,\n      };\n      keychainsGetStub.callsFake(({ id }: { id: string }) =>\n        Promise.resolve(id === 'user-key' ? userKeychain : publicOnlyKeychain(id))\n      );\n      const options = await getShareOptions(wallet);\n      options.skipKeychain.should.equal(false);\n      options.keychain.pub.should.equal('hot-pub');\n    });\n\n    it('an lnbtc wallet takes the userAuth path and never enters the safe branch', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1', coin: 'lbtc' });\n      mockBaseCoin.getFamily.returns('lnbtc');\n      const safeChildSpy = sinon.spy(wallet as any, 'getSafeOwnerChildKeychain');\n      // stubbing the private keychain fetch so lnbtc resolves a keychain without full lightning mocks\n      sinon.stub(wallet as any, 'getEncryptedWalletKeychainForWalletSharing').resolves({\n        id: 'user-key',\n        pub: 'ln-pub',\n        encryptedPrv: `enc:ln-prv`,\n        type: 'independent',\n      });\n      const options = await getShareOptions(wallet);\n      options.keychain.pub.should.equal('ln-pub');\n      safeChildSpy.notCalled.should.equal(true);\n    });\n  });\n\n  describe('createBulkWalletShare on a safe wallet', function () {\n    const bulkParams = {\n      walletPassphrase: passphrase,\n      keyShareOptions: [\n        { userId: 'u1', pubKey: SHAREE_PUB, path: 'm/0', permissions: 'spend' },\n        { userId: 'u2', pubKey: SHAREE_PUB, path: 'm/0', permissions: 'spend' },\n      ],\n    } as any;\n\n    it('derives the child once (one root decrypt) and fans it out per user', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1' });\n      await wallet.createBulkWalletShare(bulkParams);\n\n      createBulkKeySharesStub.calledOnce.should.equal(true);\n      const options = createBulkKeySharesStub.firstCall.args[0];\n      options.length.should.equal(2);\n      options.forEach((o: any) => o.keychain.pub.should.equal(hardened.pub));\n      // child + root exactly once (single root decrypt)\n      const rootCalls = keychainsGetStub.getCalls().filter((c) => c.args?.[0]?.id === rootKeyId);\n      rootCalls.length.should.equal(1);\n    });\n\n    it('the real error propagates instead of shareOptions cannot be empty', async function () {\n      const wallet = makeWallet({ safe: 'safe-id-1', multisigType: 'tss' });\n      await wallet.createBulkWalletShare(bulkParams).should.be.rejectedWith(SafeShareNotImplementedError);\n      createBulkKeySharesStub.notCalled.should.equal(true);\n    });\n  });\n});\n"]}