@bitgo/sdk-core 38.1.0 → 38.4.0

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

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

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

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

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

@@ -0,0 +1,134 @@
+"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 });
+const sinon = __importStar(require("sinon"));
+require("should");
+const src_1 = require("../../../../src");
+describe('Safe', function () {
+    let safe;
+    let mockBitGo;
+    let safeData;
+    // wire-shaped SafeData (timestamps as ISO strings) for mocked REST responses that get decoded
+    let safeDataWire;
+    beforeEach(function () {
+        mockBitGo = {
+            url: sinon.stub().callsFake((path) => path),
+            post: sinon.stub(),
+        };
+        safeData = {
+            id: 'test-safe-id',
+            enterpriseId: 'test-enterprise-id',
+            label: 'my safe',
+            status: 'active',
+            creator: 'creator-id',
+            users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],
+            createdAt: new Date('2026-07-07T00:00:00.000Z'),
+        };
+        safeDataWire = {
+            id: 'test-safe-id',
+            enterpriseId: 'test-enterprise-id',
+            label: 'my safe',
+            status: 'active',
+            creator: 'creator-id',
+            users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],
+            createdAt: '2026-07-07T00:00:00.000Z',
+        };
+        safe = new src_1.Safe(mockBitGo, safeData);
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('getters', function () {
+        it('exposes id/enterpriseId/label/status', function () {
+            safe.id().should.equal('test-safe-id');
+            safe.enterpriseId().should.equal('test-enterprise-id');
+            safe.label().should.equal('my safe');
+            safe.status().should.equal('active');
+        });
+        it('toJSON returns the underlying data', function () {
+            safe.toJSON().should.equal(safeData);
+        });
+    });
+    describe('url', function () {
+        it('builds the enterprise-scoped v2 path', function () {
+            safe.url().should.equal('/enterprise/test-enterprise-id/safes/test-safe-id');
+            safe.url('/freeze').should.equal('/enterprise/test-enterprise-id/safes/test-safe-id/freeze');
+            mockBitGo.url.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id', 2).should.be.true();
+        });
+    });
+    describe('freeze / archive REST plumbing', function () {
+        function stubPost(response) {
+            const resultStub = sinon.stub().resolves(response);
+            const sendStub = sinon.stub().returns({ result: resultStub });
+            mockBitGo.post.returns({ send: sendStub });
+            return { sendStub };
+        }
+        it('freeze posts the encoded body to the freeze route and decodes SafeData', async function () {
+            const frozen = { ...safeDataWire, freeze: { reason: 'incident' } };
+            const { sendStub } = stubPost(frozen);
+            const result = await safe.freeze({ reason: 'incident' });
+            mockBitGo.post.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id/freeze').should.be.true();
+            sendStub.calledWith({ reason: 'incident' }).should.be.true();
+            result.freeze.reason.should.equal('incident');
+            result.createdAt.should.be.instanceof(Date);
+        });
+        it('archive posts an empty body to the archive route and decodes SafeData', async function () {
+            const archived = { ...safeDataWire, status: 'archived' };
+            const { sendStub } = stubPost(archived);
+            const result = await safe.archive();
+            mockBitGo.post.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id/archive').should.be.true();
+            sendStub.calledWithExactly().should.be.true();
+            result.status.should.equal('archived');
+        });
+    });
+    describe('member/share methods are stubbed (WCN-1203 / WCN-1204)', function () {
+        it('createWallet throws not-implemented (WCN-1203)', async function () {
+            await safe.createWallet({ coin: 'tbtc', label: 'w' }).should.be.rejectedWith(/WCN-1203/);
+        });
+        it('addMember throws not-implemented (WCN-1204)', async function () {
+            await safe.addMember({ userId: 'u', permissions: ['view'] }).should.be.rejectedWith(/WCN-1204/);
+        });
+        it('addMemberToWallet throws not-implemented (WCN-1204)', async function () {
+            await safe.addMemberToWallet({ walletId: 'w', walletPassphrase: 'p' }).should.be.rejectedWith(/WCN-1204/);
+        });
+        it('listShares throws not-implemented (WCN-1204)', async function () {
+            await safe.listShares().should.be.rejectedWith(/WCN-1204/);
+        });
+        it('acceptShare throws not-implemented (WCN-1204)', async function () {
+            await safe.acceptShare({ safeShareId: 's' }).should.be.rejectedWith(/WCN-1204/);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safe.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/safe.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sinon from 'sinon';\nimport 'should';\nimport { SafeData } from '@bitgo/public-types';\nimport { Safe } from '../../../../src';\n\ndescribe('Safe', function () {\n  let safe: Safe;\n  let mockBitGo: any;\n  let safeData: SafeData;\n  // wire-shaped SafeData (timestamps as ISO strings) for mocked REST responses that get decoded\n  let safeDataWire: any;\n\n  beforeEach(function () {\n    mockBitGo = {\n      url: sinon.stub().callsFake((path: string) => path),\n      post: sinon.stub(),\n    };\n    safeData = {\n      id: 'test-safe-id',\n      enterpriseId: 'test-enterprise-id',\n      label: 'my safe',\n      status: 'active',\n      creator: 'creator-id',\n      users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],\n      createdAt: new Date('2026-07-07T00:00:00.000Z'),\n    };\n    safeDataWire = {\n      id: 'test-safe-id',\n      enterpriseId: 'test-enterprise-id',\n      label: 'my safe',\n      status: 'active',\n      creator: 'creator-id',\n      users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],\n      createdAt: '2026-07-07T00:00:00.000Z',\n    };\n    safe = new Safe(mockBitGo, safeData);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('getters', function () {\n    it('exposes id/enterpriseId/label/status', function () {\n      safe.id().should.equal('test-safe-id');\n      safe.enterpriseId().should.equal('test-enterprise-id');\n      safe.label().should.equal('my safe');\n      safe.status().should.equal('active');\n    });\n\n    it('toJSON returns the underlying data', function () {\n      safe.toJSON().should.equal(safeData);\n    });\n  });\n\n  describe('url', function () {\n    it('builds the enterprise-scoped v2 path', function () {\n      safe.url().should.equal('/enterprise/test-enterprise-id/safes/test-safe-id');\n      safe.url('/freeze').should.equal('/enterprise/test-enterprise-id/safes/test-safe-id/freeze');\n      mockBitGo.url.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id', 2).should.be.true();\n    });\n  });\n\n  describe('freeze / archive REST plumbing', function () {\n    function stubPost(response: unknown) {\n      const resultStub = sinon.stub().resolves(response);\n      const sendStub = sinon.stub().returns({ result: resultStub });\n      mockBitGo.post.returns({ send: sendStub });\n      return { sendStub };\n    }\n\n    it('freeze posts the encoded body to the freeze route and decodes SafeData', async function () {\n      const frozen = { ...safeDataWire, freeze: { reason: 'incident' } };\n      const { sendStub } = stubPost(frozen);\n      const result = await safe.freeze({ reason: 'incident' });\n      mockBitGo.post.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id/freeze').should.be.true();\n      sendStub.calledWith({ reason: 'incident' }).should.be.true();\n      result.freeze!.reason!.should.equal('incident');\n      result.createdAt.should.be.instanceof(Date);\n    });\n\n    it('archive posts an empty body to the archive route and decodes SafeData', async function () {\n      const archived = { ...safeDataWire, status: 'archived' as const };\n      const { sendStub } = stubPost(archived);\n      const result = await safe.archive();\n      mockBitGo.post.calledWith('/enterprise/test-enterprise-id/safes/test-safe-id/archive').should.be.true();\n      sendStub.calledWithExactly().should.be.true();\n      result.status.should.equal('archived');\n    });\n  });\n\n  describe('member/share methods are stubbed (WCN-1203 / WCN-1204)', function () {\n    it('createWallet throws not-implemented (WCN-1203)', async function () {\n      await safe.createWallet({ coin: 'tbtc', label: 'w' }).should.be.rejectedWith(/WCN-1203/);\n    });\n\n    it('addMember throws not-implemented (WCN-1204)', async function () {\n      await safe.addMember({ userId: 'u', permissions: ['view'] }).should.be.rejectedWith(/WCN-1204/);\n    });\n\n    it('addMemberToWallet throws not-implemented (WCN-1204)', async function () {\n      await safe.addMemberToWallet({ walletId: 'w', walletPassphrase: 'p' }).should.be.rejectedWith(/WCN-1204/);\n    });\n\n    it('listShares throws not-implemented (WCN-1204)', async function () {\n      await safe.listShares().should.be.rejectedWith(/WCN-1204/);\n    });\n\n    it('acceptShare throws not-implemented (WCN-1204)', async function () {\n      await safe.acceptShare({ safeShareId: 's' }).should.be.rejectedWith(/WCN-1204/);\n    });\n  });\n});\n"]}

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

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

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

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

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

@@ -0,0 +1,297 @@
+"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 });
+const sinon = __importStar(require("sinon"));
+require("should");
+const src_1 = require("../../../../src");
+describe('Safes', function () {
+    let safes;
+    let mockBitGo;
+    const safeDataWire = {
+        id: 'test-safe-id',
+        enterpriseId: 'test-enterprise-id',
+        label: 'my safe',
+        status: 'active',
+        creator: 'creator-id',
+        users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],
+        createdAt: '2026-07-07T00:00:00.000Z',
+    };
+    beforeEach(function () {
+        mockBitGo = {
+            url: sinon.stub().callsFake((path) => path),
+            post: sinon.stub(),
+        };
+        safes = new src_1.Safes(mockBitGo, 'test-enterprise-id');
+    });
+    afterEach(function () {
+        sinon.restore();
+    });
+    describe('initializeSafe', function () {
+        it('POSTs to the safes collection URL and returns the initializing id/status', async function () {
+            const initializeResponseWire = { id: 'test-safe-id', status: 'initializing' };
+            const send = sinon.stub().returns({ result: sinon.stub().resolves(initializeResponseWire) });
+            mockBitGo.post.returns({ send });
+            const result = await safes.initializeSafe({ label: 'my safe' });
+            result.id.should.equal('test-safe-id');
+            result.status.should.equal('initializing');
+            sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes');
+            sinon.assert.calledWith(send, { label: 'my safe' });
+        });
+    });
+    describe('createSafeKeys', function () {
+        // Per-coin keychains() mock: multisig coins use create/add/createBackup/createBitGo; MPC coins
+        // use createMpc. Ids are derived from the coin name so we can assert per-slot coin routing.
+        function makeKeychains(coin) {
+            return {
+                create: sinon.stub().returns({ pub: `${coin}-pub`, prv: `${coin}-prv` }),
+                add: sinon.stub().resolves({ id: `${coin}-user` }),
+                createBackup: sinon.stub().resolves({ id: `${coin}-backup` }),
+                createBitGo: sinon.stub().resolves({ id: `${coin}-bitgo` }),
+                createMpc: sinon.stub().resolves({
+                    userKeychain: { id: `${coin}-user` },
+                    backupKeychain: { id: `${coin}-backup` },
+                    bitgoKeychain: { id: `${coin}-bitgo` },
+                }),
+            };
+        }
+        let keychainsByCoin;
+        beforeEach(function () {
+            keychainsByCoin = {};
+            mockBitGo.getEnv = sinon.stub().returns('test'); // testnet coin map
+            mockBitGo.encrypt = sinon.stub().resolves('encrypted-prv');
+            mockBitGo.coin = sinon.stub().callsFake((name) => {
+                keychainsByCoin[name] = keychainsByCoin[name] || makeKeychains(name);
+                return { keychains: () => keychainsByCoin[name] };
+            });
+        });
+        it('runs the 4 root ceremonies and returns 12 ids as ordered triplets', async function () {
+            const result = await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });
+            result.should.deepEqual({
+                rootKeys: {
+                    hot: {
+                        secp256k1Multisig: ['tbtc-user', 'tbtc-backup', 'tbtc-bitgo'],
+                        ecdsaMpc: ['hteth-user', 'hteth-backup', 'hteth-bitgo'],
+                        eddsaMpc: ['tsol-user', 'tsol-backup', 'tsol-bitgo'],
+                        ed25519Multisig: ['txlm-user', 'txlm-backup', 'txlm-bitgo'],
+                    },
+                },
+            });
+        });
+        it('tags every multisig key registration with safeId and the correct source', async function () {
+            await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });
+            const btc = keychainsByCoin['tbtc'];
+            sinon.assert.calledWithMatch(btc.add, {
+                pub: 'tbtc-pub',
+                encryptedPrv: 'encrypted-prv',
+                source: 'user',
+                safeId: 'safe-1',
+            });
+            sinon.assert.calledWithMatch(btc.createBackup, { passphrase: 'pw', safeId: 'safe-1' });
+            sinon.assert.calledWithMatch(btc.createBitGo, { enterprise: 'test-enterprise-id', safeId: 'safe-1' });
+        });
+        it('threads safeId + enterprise into both MPC ceremonies', async function () {
+            await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });
+            sinon.assert.calledWithMatch(keychainsByCoin['hteth'].createMpc, {
+                multisigType: 'tss',
+                passphrase: 'pw',
+                enterprise: 'test-enterprise-id',
+                safeId: 'safe-1',
+            });
+            sinon.assert.calledWithMatch(keychainsByCoin['tsol'].createMpc, {
+                multisigType: 'tss',
+                passphrase: 'pw',
+                enterprise: 'test-enterprise-id',
+                safeId: 'safe-1',
+            });
+        });
+        it('selects mainnet coins in a prod environment', async function () {
+            mockBitGo.getEnv = sinon.stub().returns('prod');
+            await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });
+            sinon.assert.calledWith(mockBitGo.coin, 'btc');
+            sinon.assert.calledWith(mockBitGo.coin, 'eth');
+            sinon.assert.calledWith(mockBitGo.coin, 'sol');
+            sinon.assert.calledWith(mockBitGo.coin, 'xlm');
+        });
+        it('runs the 4 root ceremonies in parallel (none awaits another)', async function () {
+            // Gate exactly one call per root on a shared latch that only opens once all 4 roots have
+            // entered. If the roots ran sequentially, the first would await the latch forever → the
+            // test would time out; completing proves all 4 were in flight concurrently.
+            let release = () => undefined;
+            const gate = new Promise((resolve) => (release = resolve));
+            let started = 0;
+            const gated = (result) => sinon.stub().callsFake(async () => {
+                if (++started === 4) {
+                    release();
+                }
+                await gate;
+                return result;
+            });
+            // one gated entry point per root: multisig roots via createBitGo, MPC roots via createMpc
+            keychainsByCoin['tbtc'] = makeKeychains('tbtc');
+            keychainsByCoin['tbtc'].createBitGo = gated({ id: 'tbtc-bitgo' });
+            keychainsByCoin['txlm'] = makeKeychains('txlm');
+            keychainsByCoin['txlm'].createBitGo = gated({ id: 'txlm-bitgo' });
+            keychainsByCoin['hteth'] = makeKeychains('hteth');
+            keychainsByCoin['hteth'].createMpc = gated({
+                userKeychain: { id: 'hteth-user' },
+                backupKeychain: { id: 'hteth-backup' },
+                bitgoKeychain: { id: 'hteth-bitgo' },
+            });
+            keychainsByCoin['tsol'] = makeKeychains('tsol');
+            keychainsByCoin['tsol'].createMpc = gated({
+                userKeychain: { id: 'tsol-user' },
+                backupKeychain: { id: 'tsol-backup' },
+                bitgoKeychain: { id: 'tsol-bitgo' },
+            });
+            await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });
+            started.should.equal(4);
+        });
+        it('archives the safe and throws listing every failed ceremony', async function () {
+            // Two ceremonies fail (an MPC and a multisig root).
+            keychainsByCoin['hteth'] = makeKeychains('hteth');
+            keychainsByCoin['hteth'].createMpc = sinon.stub().rejects(new Error('dkls boom'));
+            keychainsByCoin['txlm'] = makeKeychains('txlm');
+            keychainsByCoin['txlm'].createBitGo = sinon.stub().rejects(new Error('bitgo key boom'));
+            // archive succeeds, returning a valid (archived) SafeData
+            const send = sinon.stub().returns({
+                result: sinon.stub().resolves({ ...safeDataWire, status: 'archived' }),
+            });
+            mockBitGo.post.returns({ send });
+            const err = await safes
+                .createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' })
+                .should.be.rejectedWith(/Safe key generation failed for 2 root/);
+            err.message.should.match(/ecdsaMpc: dkls boom/);
+            err.message.should.match(/ed25519Multisig: bitgo key boom/);
+            err.message.should.match(/has been archived/);
+            err.message.should.not.match(/archiving the safe also failed/);
+            sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/safe-1/archive');
+        });
+        it('notes when archiving also fails', async function () {
+            keychainsByCoin['tsol'] = makeKeychains('tsol');
+            keychainsByCoin['tsol'].createMpc = sinon.stub().rejects(new Error('eddsa boom'));
+            mockBitGo.post.returns({
+                send: sinon.stub().returns({ result: sinon.stub().rejects(new Error('archive 500')) }),
+            });
+            await safes
+                .createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' })
+                .should.be.rejectedWith(/archiving the safe also failed \(archive 500\).*archive it manually/);
+        });
+    });
+    describe('finalizeSafe', function () {
+        const rootKeys = {
+            hot: {
+                secp256k1Multisig: ['u1', 'b1', 'g1'],
+                ecdsaMpc: ['u2', 'b2', 'g2'],
+                eddsaMpc: ['u3', 'b3', 'g3'],
+                ed25519Multisig: ['u4', 'b4', 'g4'],
+            },
+        };
+        it('POSTs the rootKeys to the finalize URL and returns the active Safe', async function () {
+            const send = sinon.stub().returns({ result: sinon.stub().resolves(safeDataWire) });
+            mockBitGo.post.returns({ send });
+            const result = await safes.finalizeSafe('test-safe-id', { rootKeys });
+            result.should.be.instanceof(src_1.Safe);
+            result.status().should.equal('active');
+            sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/test-safe-id/finalize');
+            sinon.assert.calledWithMatch(send, { rootKeys });
+        });
+    });
+    describe('archiveSafe', function () {
+        it('POSTs to the archive URL and returns the archived Safe', async function () {
+            const send = sinon.stub().returns({ result: sinon.stub().resolves({ ...safeDataWire, status: 'archived' }) });
+            mockBitGo.post.returns({ send });
+            const result = await safes.archiveSafe('test-safe-id');
+            result.should.be.instanceof(src_1.Safe);
+            result.status().should.equal('archived');
+            sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/test-safe-id/archive');
+        });
+    });
+    describe('generateSafe', function () {
+        it('chains initialize → createSafeKeys → finalize, threading the safeId', async function () {
+            const initializing = { id: 'test-safe-id', status: 'initializing' };
+            const rootKeys = { rootKeys: { hot: {} } };
+            const initStub = sinon.stub(safes, 'initializeSafe').resolves(initializing);
+            const keysStub = sinon.stub(safes, 'createSafeKeys').resolves(rootKeys);
+            const finalizeStub = sinon.stub(safes, 'finalizeSafe').resolves(new src_1.Safe(mockBitGo, safeDataWire));
+            const result = await safes.generateSafe({ label: 'my safe', passphrase: 'pw' });
+            sinon.assert.calledWithMatch(initStub, { label: 'my safe' });
+            sinon.assert.calledWithMatch(keysStub, { label: 'my safe', passphrase: 'pw', safeId: 'test-safe-id' });
+            sinon.assert.calledWith(finalizeStub, 'test-safe-id', rootKeys);
+            sinon.assert.callOrder(initStub, keysStub, finalizeStub);
+            result.status().should.equal('active');
+        });
+    });
+    describe('get', function () {
+        it('GETs the safe URL and returns a Safe', async function () {
+            mockBitGo.get = sinon.stub().returns({ result: sinon.stub().resolves(safeDataWire) });
+            const result = await safes.get({ id: 'test-safe-id' });
+            result.should.be.instanceof(src_1.Safe);
+            result.id().should.equal('test-safe-id');
+            sinon.assert.calledWith(mockBitGo.get, '/enterprise/test-enterprise-id/safes/test-safe-id');
+        });
+    });
+    describe('list', function () {
+        it('GETs the safes collection and maps the response to Safes', async function () {
+            const query = sinon.stub().returnsThis();
+            const result = sinon.stub().resolves({ safes: [safeDataWire], nextBatchPrevId: 'next-page-id' });
+            mockBitGo.get = sinon.stub().returns({ query, result });
+            const page = await safes.list();
+            page.safes.should.have.length(1);
+            page.safes[0].should.be.instanceof(src_1.Safe);
+            page.safes[0].id().should.equal('test-safe-id');
+            page.should.have.property('nextCursor', 'next-page-id');
+            sinon.assert.calledWith(mockBitGo.get, '/enterprise/test-enterprise-id/safes');
+            // no cursor/limit passed → empty query
+            sinon.assert.calledWith(query, {});
+        });
+        it('maps cursor→prevId and limit onto the query', async function () {
+            const query = sinon.stub().returnsThis();
+            const result = sinon.stub().resolves({ safes: [] });
+            mockBitGo.get = sinon.stub().returns({ query, result });
+            const page = await safes.list({ cursor: 'prev-page-id', limit: 50 });
+            page.safes.should.have.length(0);
+            // absent nextBatchPrevId → undefined nextCursor (last page)
+            (page.nextCursor === undefined).should.be.true();
+            sinon.assert.calledWith(query, { limit: 50, prevId: 'prev-page-id' });
+        });
+    });
+    describe('Enterprise.safes() accessor', function () {
+        it('returns a Safes instance scoped to the enterprise', function () {
+            const enterprise = new src_1.Enterprise(mockBitGo, {}, { id: 'ent-id', name: 'ent' });
+            enterprise.safes().should.be.instanceof(src_1.Safes);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"safes.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/safe/safes.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sinon from 'sinon';\nimport 'should';\nimport { Enterprise, Safe, Safes } from '../../../../src';\n\ndescribe('Safes', function () {\n  let safes: Safes;\n  let mockBitGo: any;\n  const safeDataWire = {\n    id: 'test-safe-id',\n    enterpriseId: 'test-enterprise-id',\n    label: 'my safe',\n    status: 'active',\n    creator: 'creator-id',\n    users: [{ userId: 'creator-id', permissions: ['admin', 'spend'] }],\n    createdAt: '2026-07-07T00:00:00.000Z',\n  };\n\n  beforeEach(function () {\n    mockBitGo = {\n      url: sinon.stub().callsFake((path: string) => path),\n      post: sinon.stub(),\n    };\n    safes = new Safes(mockBitGo, 'test-enterprise-id');\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('initializeSafe', function () {\n    it('POSTs to the safes collection URL and returns the initializing id/status', async function () {\n      const initializeResponseWire = { id: 'test-safe-id', status: 'initializing' };\n      const send = sinon.stub().returns({ result: sinon.stub().resolves(initializeResponseWire) });\n      mockBitGo.post.returns({ send });\n\n      const result = await safes.initializeSafe({ label: 'my safe' });\n\n      result.id.should.equal('test-safe-id');\n      result.status.should.equal('initializing');\n      sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes');\n      sinon.assert.calledWith(send, { label: 'my safe' });\n    });\n  });\n\n  describe('createSafeKeys', function () {\n    // Per-coin keychains() mock: multisig coins use create/add/createBackup/createBitGo; MPC coins\n    // use createMpc. Ids are derived from the coin name so we can assert per-slot coin routing.\n    function makeKeychains(coin: string) {\n      return {\n        create: sinon.stub().returns({ pub: `${coin}-pub`, prv: `${coin}-prv` }),\n        add: sinon.stub().resolves({ id: `${coin}-user` }),\n        createBackup: sinon.stub().resolves({ id: `${coin}-backup` }),\n        createBitGo: sinon.stub().resolves({ id: `${coin}-bitgo` }),\n        createMpc: sinon.stub().resolves({\n          userKeychain: { id: `${coin}-user` },\n          backupKeychain: { id: `${coin}-backup` },\n          bitgoKeychain: { id: `${coin}-bitgo` },\n        }),\n      };\n    }\n\n    let keychainsByCoin: Record<string, ReturnType<typeof makeKeychains>>;\n\n    beforeEach(function () {\n      keychainsByCoin = {};\n      mockBitGo.getEnv = sinon.stub().returns('test'); // testnet coin map\n      mockBitGo.encrypt = sinon.stub().resolves('encrypted-prv');\n      mockBitGo.coin = sinon.stub().callsFake((name: string) => {\n        keychainsByCoin[name] = keychainsByCoin[name] || makeKeychains(name);\n        return { keychains: () => keychainsByCoin[name] };\n      });\n    });\n\n    it('runs the 4 root ceremonies and returns 12 ids as ordered triplets', async function () {\n      const result = await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });\n\n      result.should.deepEqual({\n        rootKeys: {\n          hot: {\n            secp256k1Multisig: ['tbtc-user', 'tbtc-backup', 'tbtc-bitgo'],\n            ecdsaMpc: ['hteth-user', 'hteth-backup', 'hteth-bitgo'],\n            eddsaMpc: ['tsol-user', 'tsol-backup', 'tsol-bitgo'],\n            ed25519Multisig: ['txlm-user', 'txlm-backup', 'txlm-bitgo'],\n          },\n        },\n      });\n    });\n\n    it('tags every multisig key registration with safeId and the correct source', async function () {\n      await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });\n\n      const btc = keychainsByCoin['tbtc'];\n      sinon.assert.calledWithMatch(btc.add, {\n        pub: 'tbtc-pub',\n        encryptedPrv: 'encrypted-prv',\n        source: 'user',\n        safeId: 'safe-1',\n      });\n      sinon.assert.calledWithMatch(btc.createBackup, { passphrase: 'pw', safeId: 'safe-1' });\n      sinon.assert.calledWithMatch(btc.createBitGo, { enterprise: 'test-enterprise-id', safeId: 'safe-1' });\n    });\n\n    it('threads safeId + enterprise into both MPC ceremonies', async function () {\n      await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });\n\n      sinon.assert.calledWithMatch(keychainsByCoin['hteth'].createMpc, {\n        multisigType: 'tss',\n        passphrase: 'pw',\n        enterprise: 'test-enterprise-id',\n        safeId: 'safe-1',\n      });\n      sinon.assert.calledWithMatch(keychainsByCoin['tsol'].createMpc, {\n        multisigType: 'tss',\n        passphrase: 'pw',\n        enterprise: 'test-enterprise-id',\n        safeId: 'safe-1',\n      });\n    });\n\n    it('selects mainnet coins in a prod environment', async function () {\n      mockBitGo.getEnv = sinon.stub().returns('prod');\n      await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });\n\n      sinon.assert.calledWith(mockBitGo.coin, 'btc');\n      sinon.assert.calledWith(mockBitGo.coin, 'eth');\n      sinon.assert.calledWith(mockBitGo.coin, 'sol');\n      sinon.assert.calledWith(mockBitGo.coin, 'xlm');\n    });\n\n    it('runs the 4 root ceremonies in parallel (none awaits another)', async function () {\n      // Gate exactly one call per root on a shared latch that only opens once all 4 roots have\n      // entered. If the roots ran sequentially, the first would await the latch forever → the\n      // test would time out; completing proves all 4 were in flight concurrently.\n      let release: () => void = () => undefined;\n      const gate = new Promise<void>((resolve) => (release = resolve));\n      let started = 0;\n      const gated = (result: any) =>\n        sinon.stub().callsFake(async () => {\n          if (++started === 4) {\n            release();\n          }\n          await gate;\n          return result;\n        });\n      // one gated entry point per root: multisig roots via createBitGo, MPC roots via createMpc\n      keychainsByCoin['tbtc'] = makeKeychains('tbtc');\n      keychainsByCoin['tbtc'].createBitGo = gated({ id: 'tbtc-bitgo' });\n      keychainsByCoin['txlm'] = makeKeychains('txlm');\n      keychainsByCoin['txlm'].createBitGo = gated({ id: 'txlm-bitgo' });\n      keychainsByCoin['hteth'] = makeKeychains('hteth');\n      keychainsByCoin['hteth'].createMpc = gated({\n        userKeychain: { id: 'hteth-user' },\n        backupKeychain: { id: 'hteth-backup' },\n        bitgoKeychain: { id: 'hteth-bitgo' },\n      });\n      keychainsByCoin['tsol'] = makeKeychains('tsol');\n      keychainsByCoin['tsol'].createMpc = gated({\n        userKeychain: { id: 'tsol-user' },\n        backupKeychain: { id: 'tsol-backup' },\n        bitgoKeychain: { id: 'tsol-bitgo' },\n      });\n\n      await safes.createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' });\n      started.should.equal(4);\n    });\n\n    it('archives the safe and throws listing every failed ceremony', async function () {\n      // Two ceremonies fail (an MPC and a multisig root).\n      keychainsByCoin['hteth'] = makeKeychains('hteth');\n      keychainsByCoin['hteth'].createMpc = sinon.stub().rejects(new Error('dkls boom'));\n      keychainsByCoin['txlm'] = makeKeychains('txlm');\n      keychainsByCoin['txlm'].createBitGo = sinon.stub().rejects(new Error('bitgo key boom'));\n      // archive succeeds, returning a valid (archived) SafeData\n      const send = sinon.stub().returns({\n        result: sinon.stub().resolves({ ...safeDataWire, status: 'archived' }),\n      });\n      mockBitGo.post.returns({ send });\n\n      const err = await safes\n        .createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' })\n        .should.be.rejectedWith(/Safe key generation failed for 2 root/);\n      err.message.should.match(/ecdsaMpc: dkls boom/);\n      err.message.should.match(/ed25519Multisig: bitgo key boom/);\n      err.message.should.match(/has been archived/);\n      err.message.should.not.match(/archiving the safe also failed/);\n      sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/safe-1/archive');\n    });\n\n    it('notes when archiving also fails', async function () {\n      keychainsByCoin['tsol'] = makeKeychains('tsol');\n      keychainsByCoin['tsol'].createMpc = sinon.stub().rejects(new Error('eddsa boom'));\n      mockBitGo.post.returns({\n        send: sinon.stub().returns({ result: sinon.stub().rejects(new Error('archive 500')) }),\n      });\n\n      await safes\n        .createSafeKeys({ label: 'my safe', passphrase: 'pw', safeId: 'safe-1' })\n        .should.be.rejectedWith(/archiving the safe also failed \\(archive 500\\).*archive it manually/);\n    });\n  });\n\n  describe('finalizeSafe', function () {\n    const rootKeys = {\n      hot: {\n        secp256k1Multisig: ['u1', 'b1', 'g1'] as [string, string, string],\n        ecdsaMpc: ['u2', 'b2', 'g2'] as [string, string, string],\n        eddsaMpc: ['u3', 'b3', 'g3'] as [string, string, string],\n        ed25519Multisig: ['u4', 'b4', 'g4'] as [string, string, string],\n      },\n    };\n\n    it('POSTs the rootKeys to the finalize URL and returns the active Safe', async function () {\n      const send = sinon.stub().returns({ result: sinon.stub().resolves(safeDataWire) });\n      mockBitGo.post.returns({ send });\n\n      const result = await safes.finalizeSafe('test-safe-id', { rootKeys });\n\n      result.should.be.instanceof(Safe);\n      result.status().should.equal('active');\n      sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/test-safe-id/finalize');\n      sinon.assert.calledWithMatch(send, { rootKeys });\n    });\n  });\n\n  describe('archiveSafe', function () {\n    it('POSTs to the archive URL and returns the archived Safe', async function () {\n      const send = sinon.stub().returns({ result: sinon.stub().resolves({ ...safeDataWire, status: 'archived' }) });\n      mockBitGo.post.returns({ send });\n\n      const result = await safes.archiveSafe('test-safe-id');\n\n      result.should.be.instanceof(Safe);\n      result.status().should.equal('archived');\n      sinon.assert.calledWith(mockBitGo.post, '/enterprise/test-enterprise-id/safes/test-safe-id/archive');\n    });\n  });\n\n  describe('generateSafe', function () {\n    it('chains initialize → createSafeKeys → finalize, threading the safeId', async function () {\n      const initializing = { id: 'test-safe-id', status: 'initializing' as const };\n      const rootKeys = { rootKeys: { hot: {} } } as any;\n      const initStub = sinon.stub(safes, 'initializeSafe').resolves(initializing);\n      const keysStub = sinon.stub(safes, 'createSafeKeys').resolves(rootKeys);\n      const finalizeStub = sinon.stub(safes, 'finalizeSafe').resolves(new Safe(mockBitGo, safeDataWire as any));\n\n      const result = await safes.generateSafe({ label: 'my safe', passphrase: 'pw' });\n\n      sinon.assert.calledWithMatch(initStub, { label: 'my safe' });\n      sinon.assert.calledWithMatch(keysStub, { label: 'my safe', passphrase: 'pw', safeId: 'test-safe-id' });\n      sinon.assert.calledWith(finalizeStub, 'test-safe-id', rootKeys);\n      sinon.assert.callOrder(initStub, keysStub, finalizeStub);\n      result.status().should.equal('active');\n    });\n  });\n\n  describe('get', function () {\n    it('GETs the safe URL and returns a Safe', async function () {\n      mockBitGo.get = sinon.stub().returns({ result: sinon.stub().resolves(safeDataWire) });\n\n      const result = await safes.get({ id: 'test-safe-id' });\n\n      result.should.be.instanceof(Safe);\n      result.id().should.equal('test-safe-id');\n      sinon.assert.calledWith(mockBitGo.get, '/enterprise/test-enterprise-id/safes/test-safe-id');\n    });\n  });\n\n  describe('list', function () {\n    it('GETs the safes collection and maps the response to Safes', async function () {\n      const query = sinon.stub().returnsThis();\n      const result = sinon.stub().resolves({ safes: [safeDataWire], nextBatchPrevId: 'next-page-id' });\n      mockBitGo.get = sinon.stub().returns({ query, result });\n\n      const page = await safes.list();\n\n      page.safes.should.have.length(1);\n      page.safes[0].should.be.instanceof(Safe);\n      page.safes[0].id().should.equal('test-safe-id');\n      page.should.have.property('nextCursor', 'next-page-id');\n      sinon.assert.calledWith(mockBitGo.get, '/enterprise/test-enterprise-id/safes');\n      // no cursor/limit passed → empty query\n      sinon.assert.calledWith(query, {});\n    });\n\n    it('maps cursor→prevId and limit onto the query', async function () {\n      const query = sinon.stub().returnsThis();\n      const result = sinon.stub().resolves({ safes: [] });\n      mockBitGo.get = sinon.stub().returns({ query, result });\n\n      const page = await safes.list({ cursor: 'prev-page-id', limit: 50 });\n\n      page.safes.should.have.length(0);\n      // absent nextBatchPrevId → undefined nextCursor (last page)\n      (page.nextCursor === undefined).should.be.true();\n      sinon.assert.calledWith(query, { limit: 50, prevId: 'prev-page-id' });\n    });\n  });\n\n  describe('Enterprise.safes() accessor', function () {\n    it('returns a Safes instance scoped to the enterprise', function () {\n      const enterprise = new Enterprise(mockBitGo, {} as any, { id: 'ent-id', name: 'ent' });\n      enterprise.safes().should.be.instanceof(Safes);\n    });\n  });\n});\n"]}