@bitgo-beta/sdk-core 8.2.1-beta.202 → 8.2.1-beta.2021

package/dist/test/unit/bitgo/trading/network/network.test.js

@@ -0,0 +1,136 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @prettier
+ */
+const assert_1 = __importDefault(require("assert"));
+const sinon_1 = __importDefault(require("sinon"));
+const src_1 = require("../../../../../src");
+describe('TradingNetwork', function () {
+    const enterpriseId = 'enterprise-id';
+    const walletId = 'wallet-id';
+    const signature = 'signature';
+    let mockBitGo;
+    let mockWallet;
+    let requestCalls;
+    let tradingNetwork;
+    let tradingAccount;
+    beforeEach(function () {
+        requestCalls = [];
+        tradingAccount = { signPayload: sinon_1.default.stub().resolves(signature) };
+        mockWallet = {
+            id: sinon_1.default.stub().returns(walletId),
+            toTradingAccount: sinon_1.default.stub().returns(tradingAccount),
+        };
+        mockBitGo = {
+            microservicesUrl: sinon_1.default.stub().callsFake((path) => `https://microservices.example${path}`),
+        };
+        for (const method of ['get', 'post', 'put']) {
+            mockBitGo[method] = sinon_1.default.stub().callsFake((url) => {
+                const call = {
+                    method,
+                    url,
+                    headers: {},
+                    body: undefined,
+                };
+                requestCalls.push(call);
+                const request = {
+                    set: sinon_1.default.stub().callsFake((name, value) => {
+                        call.headers[name] = value;
+                        return request;
+                    }),
+                    send: sinon_1.default.stub().callsFake((body) => {
+                        call.body = body;
+                        return request;
+                    }),
+                    result: sinon_1.default.stub().resolves({ ok: true }),
+                };
+                return request;
+            });
+        }
+        tradingNetwork = new src_1.TradingNetwork(enterpriseId, mockWallet, mockBitGo);
+    });
+    it('uses enterprise-scoped URLs and headers for network reads', async function () {
+        await tradingNetwork.getBalances({ pageNumber: 2 });
+        await tradingNetwork.getSettlementById({ settlementId: 'settlement-id' });
+        assert_1.default.deepStrictEqual(requestCalls, [
+            {
+                method: 'get',
+                url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/balances',
+                headers: { 'enterprise-id': enterpriseId },
+                body: { pageNumber: 2 },
+            },
+            {
+                method: 'get',
+                url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/settlements/settlement-id',
+                headers: { 'enterprise-id': enterpriseId },
+                body: {},
+            },
+        ]);
+    });
+    it('prepares a signed allocation with generated identifiers', async function () {
+        const prepared = await tradingNetwork.prepareAllocation({
+            connectionId: 'connection-id',
+            amount: { currency: 'tbtc', quantity: '100' },
+            notes: 'test',
+        });
+        assert_1.default.strictEqual(prepared.connectionId, 'connection-id');
+        assert_1.default.strictEqual(prepared.signature, signature);
+        assert_1.default.match(prepared.clientExternalId, /^[0-9a-f-]{36}$/);
+        assert_1.default.match(prepared.nonce, /^[0-9a-f]{64}$/);
+        assert_1.default.strictEqual(prepared.payload, JSON.stringify({
+            connectionId: 'connection-id',
+            amount: { currency: 'tbtc', quantity: '100' },
+            notes: 'test',
+            clientExternalId: prepared.clientExternalId,
+            nonce: prepared.nonce,
+        }));
+        tradingAccount.signPayload.calledOnce.should.be.true();
+        tradingAccount.signPayload.firstCall.args[0].should.deepEqual({
+            payload: prepared.payload,
+            walletPassphrase: undefined,
+        });
+    });
+    it('submits allocation and deallocation payloads to connection-scoped endpoints', async function () {
+        const params = {
+            connectionId: 'connection-id',
+            payload: '{}',
+            signature,
+            amount: { currency: 'tbtc', quantity: '100' },
+            clientExternalId: 'external-id',
+            nonce: 'nonce',
+        };
+        await tradingNetwork.createAllocation(params);
+        await tradingNetwork.createDeallocation(params);
+        assert_1.default.deepStrictEqual(requestCalls, [
+            {
+                method: 'post',
+                url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/connections/connection-id/allocations',
+                headers: { 'enterprise-id': enterpriseId },
+                body: {
+                    payload: params.payload,
+                    signature: params.signature,
+                    amount: params.amount,
+                    clientExternalId: params.clientExternalId,
+                    nonce: params.nonce,
+                },
+            },
+            {
+                method: 'post',
+                url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/connections/connection-id/deallocations',
+                headers: { 'enterprise-id': enterpriseId },
+                body: {
+                    payload: params.payload,
+                    signature: params.signature,
+                    amount: params.amount,
+                    clientExternalId: params.clientExternalId,
+                    nonce: params.nonce,
+                },
+            },
+        ]);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"network.test.js","sourceRoot":"","sources":["../../../../../../test/unit/bitgo/trading/network/network.test.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport assert from 'assert';\nimport sinon from 'sinon';\nimport { TradingNetwork } from '../../../../../src';\n\ndescribe('TradingNetwork', function () {\n  const enterpriseId = 'enterprise-id';\n  const walletId = 'wallet-id';\n  const signature = 'signature';\n  let mockBitGo: any;\n  let mockWallet: any;\n  let requestCalls: Array<{\n    method: string;\n    url: string;\n    headers: Record<string, string>;\n    body: unknown;\n  }>;\n  let tradingNetwork: TradingNetwork;\n  let tradingAccount: { signPayload: sinon.SinonStub };\n\n  beforeEach(function () {\n    requestCalls = [];\n    tradingAccount = { signPayload: sinon.stub().resolves(signature) };\n    mockWallet = {\n      id: sinon.stub().returns(walletId),\n      toTradingAccount: sinon.stub().returns(tradingAccount),\n    };\n\n    mockBitGo = {\n      microservicesUrl: sinon.stub().callsFake((path: string) => `https://microservices.example${path}`),\n    };\n\n    for (const method of ['get', 'post', 'put']) {\n      mockBitGo[method] = sinon.stub().callsFake((url: string) => {\n        const call: { method: string; url: string; headers: Record<string, string>; body: unknown } = {\n          method,\n          url,\n          headers: {},\n          body: undefined,\n        };\n        requestCalls.push(call);\n        const request = {\n          set: sinon.stub().callsFake((name: string, value: string) => {\n            call.headers[name] = value;\n            return request;\n          }),\n          send: sinon.stub().callsFake((body: unknown) => {\n            call.body = body;\n            return request;\n          }),\n          result: sinon.stub().resolves({ ok: true }),\n        };\n        return request;\n      });\n    }\n\n    tradingNetwork = new TradingNetwork(enterpriseId, mockWallet, mockBitGo);\n  });\n\n  it('uses enterprise-scoped URLs and headers for network reads', async function () {\n    await tradingNetwork.getBalances({ pageNumber: 2 });\n    await tradingNetwork.getSettlementById({ settlementId: 'settlement-id' });\n\n    assert.deepStrictEqual(requestCalls, [\n      {\n        method: 'get',\n        url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/balances',\n        headers: { 'enterprise-id': enterpriseId },\n        body: { pageNumber: 2 },\n      },\n      {\n        method: 'get',\n        url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/settlements/settlement-id',\n        headers: { 'enterprise-id': enterpriseId },\n        body: {},\n      },\n    ]);\n  });\n\n  it('prepares a signed allocation with generated identifiers', async function () {\n    const prepared = await tradingNetwork.prepareAllocation({\n      connectionId: 'connection-id',\n      amount: { currency: 'tbtc' as string, quantity: '100' },\n      notes: 'test',\n    });\n\n    assert.strictEqual(prepared.connectionId, 'connection-id');\n    assert.strictEqual(prepared.signature, signature);\n    assert.match(prepared.clientExternalId, /^[0-9a-f-]{36}$/);\n    assert.match(prepared.nonce, /^[0-9a-f]{64}$/);\n    assert.strictEqual(\n      prepared.payload,\n      JSON.stringify({\n        connectionId: 'connection-id',\n        amount: { currency: 'tbtc', quantity: '100' },\n        notes: 'test',\n        clientExternalId: prepared.clientExternalId,\n        nonce: prepared.nonce,\n      })\n    );\n    tradingAccount.signPayload.calledOnce.should.be.true();\n    tradingAccount.signPayload.firstCall.args[0].should.deepEqual({\n      payload: prepared.payload,\n      walletPassphrase: undefined,\n    });\n  });\n\n  it('submits allocation and deallocation payloads to connection-scoped endpoints', async function () {\n    const params = {\n      connectionId: 'connection-id',\n      payload: '{}',\n      signature,\n      amount: { currency: 'tbtc', quantity: '100' },\n      clientExternalId: 'external-id',\n      nonce: 'nonce',\n    };\n\n    await tradingNetwork.createAllocation(params);\n    await tradingNetwork.createDeallocation(params);\n\n    assert.deepStrictEqual(requestCalls, [\n      {\n        method: 'post',\n        url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/connections/connection-id/allocations',\n        headers: { 'enterprise-id': enterpriseId },\n        body: {\n          payload: params.payload,\n          signature: params.signature,\n          amount: params.amount,\n          clientExternalId: params.clientExternalId,\n          nonce: params.nonce,\n        },\n      },\n      {\n        method: 'post',\n        url: 'https://microservices.example/api/network/v1/enterprises/enterprise-id/clients/connections/connection-id/deallocations',\n        headers: { 'enterprise-id': enterpriseId },\n        body: {\n          payload: params.payload,\n          signature: params.signature,\n          amount: params.amount,\n          clientExternalId: params.clientExternalId,\n          nonce: params.nonce,\n        },\n      },\n    ]);\n  });\n});\n"]}

package/dist/test/unit/bitgo/trading/tradingAccount.d.ts

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

package/dist/test/unit/bitgo/trading/tradingAccount.d.ts.map

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

package/dist/test/unit/bitgo/trading/tradingAccount.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * @prettier
+ */
+const sinon_1 = __importDefault(require("sinon"));
+require("should");
+const tradingAccount_1 = require("../../../../src/bitgo/trading/tradingAccount");
+describe('TradingAccount', function () {
+    let tradingAccount;
+    let userKeyRequiredTradingAccount;
+    let mockBitGo;
+    let mockWallet;
+    let mockUserKeyRequiredWallet;
+    let mockBaseCoin;
+    let sendStub;
+    const enterpriseId = 'test-enterprise-id';
+    const walletPassphrase = 'test-passphrase';
+    const encryptedPrv = 'encrypted-prv';
+    const decryptedPrv = 'decrypted-prv';
+    const signature = 'aabbccdd';
+    const payload = { data: 'test-payload' };
+    const payloadString = JSON.stringify(payload);
+    beforeEach(function () {
+        sendStub = sinon_1.default.stub();
+        sendStub.withArgs({ payload: payloadString }).returns({ result: sinon_1.default.stub().resolves({ signature }) });
+        mockBitGo = {
+            post: sinon_1.default.stub().returns({ send: sendStub }),
+            coin: sinon_1.default.stub().callsFake((coin) => ({
+                url: sinon_1.default.stub().callsFake((url) => `https://app.bitgo-staging.com/api/v2/${coin}${url}`),
+            })),
+            decrypt: sinon_1.default
+                .stub()
+                .callsFake(async ({ input, password }) => input === encryptedPrv && password === walletPassphrase ? decryptedPrv : undefined),
+        };
+        mockBaseCoin = {
+            keychains: sinon_1.default.stub().returns({
+                get: sinon_1.default.stub().resolves({ encryptedPrv }),
+            }),
+            signMessage: sinon_1.default.stub().callsFake(async (key) => {
+                if (key.prv === decryptedPrv) {
+                    return Buffer.from(signature, 'hex');
+                }
+                throw new Error(`signMessage called with unexpected prv: ${key.prv}`);
+            }),
+        };
+        mockWallet = {
+            id: sinon_1.default.stub().returns('test-wallet-id'),
+            keyIds: sinon_1.default.stub().returns(['user-key-id', 'bitgo-key-id']),
+            toJSON: sinon_1.default.stub().returns({
+                id: 'test-wallet-id',
+                keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],
+                coinSpecific: {
+                    userKeySigningRequired: false,
+                },
+            }),
+            baseCoin: mockBaseCoin,
+            bitgo: mockBitGo,
+        };
+        mockUserKeyRequiredWallet = {
+            ...mockWallet,
+            toJSON: sinon_1.default.stub().returns({
+                id: 'test-wallet-id',
+                keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],
+                coinSpecific: {
+                    userKeySigningRequired: true,
+                },
+            }),
+        };
+        tradingAccount = new tradingAccount_1.TradingAccount(enterpriseId, mockWallet, mockBitGo);
+        userKeyRequiredTradingAccount = new tradingAccount_1.TradingAccount(enterpriseId, mockUserKeyRequiredWallet, mockBitGo);
+    });
+    afterEach(function () {
+        sinon_1.default.restore();
+    });
+    describe('id', function () {
+        it('should return the wallet id', function () {
+            tradingAccount.id.should.equal('test-wallet-id');
+            mockWallet.id.calledOnce.should.be.true();
+        });
+    });
+    describe('signPayload', function () {
+        it('should call the right url', async function () {
+            const expectedUrl = `https://app.bitgo-staging.com/api/v2/ofc/wallet/test-wallet-id/tx/sign`;
+            await tradingAccount.signPayload({ payload });
+            mockBitGo.post.calledWith(expectedUrl).should.be.true();
+        });
+        describe('without walletPassphrase or prv (BitGo remote signing)', function () {
+            it('should sign using the BitGo key remotely when no passphrase is provided', async function () {
+                const result = await tradingAccount.signPayload({ payload });
+                mockBitGo.post.calledOnce.should.be.true();
+                sendStub.calledWith({ payload: JSON.stringify(payload) }).should.be.true();
+                result.should.equal(signature);
+            });
+            it('should sign a string payload remotely when no passphrase is provided', async function () {
+                const result = await tradingAccount.signPayload({ payload: payloadString });
+                sendStub.calledWith({ payload: payloadString }).should.be.true();
+                result.should.equal(signature);
+            });
+            it('should throw if coinSpecific.userKeySigningRequired is true and no passphrase and prv are provided', async function () {
+                await userKeyRequiredTradingAccount
+                    .signPayload({ payload })
+                    .should.be.rejectedWith('Wallet must use user key to sign ofc transaction, please provide the wallet passphrase, the private key, or visit your wallet settings page to configure one.');
+            });
+            it('should fall back to top-level userKeySigningRequired when coinSpecific does not carry it', async function () {
+                await userKeyRequiredTradingAccount
+                    .signPayload({ payload })
+                    .should.be.rejectedWith('Wallet must use user key to sign ofc transaction, please provide the wallet passphrase, the private key, or visit your wallet settings page to configure one.');
+            });
+            it('should prefer coinSpecific.userKeySigningRequired over top-level when both are present', async function () {
+                mockWallet.toJSON.onCall(mockWallet.toJSON.callCount).returns({
+                    id: 'test-wallet-id',
+                    keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],
+                    coinSpecific: { userKeySigningRequired: false },
+                    userKeySigningRequired: true,
+                });
+                const result = await tradingAccount.signPayload({ payload });
+                result.should.equal(signature);
+            });
+            it('should throw if wallet has fewer than 2 keys and no passphrase and prv are provided', async function () {
+                mockWallet.toJSON.onCall(mockWallet.toJSON.callCount).returns({
+                    id: 'test-wallet-id',
+                    keys: ['user-key-id'],
+                    coinSpecific: {},
+                });
+                await tradingAccount
+                    .signPayload({ payload })
+                    .should.be.rejectedWith('Wallet does not support BitGo signing. Please reach out to support@bitgo.com to resolve this issue.');
+            });
+        });
+        describe('with walletPassphrase (local user key signing)', function () {
+            it('should decrypt the user key and sign the payload locally', async function () {
+                const result = await tradingAccount.signPayload({ payload, walletPassphrase });
+                mockBaseCoin.keychains().get.calledWith({ id: 'user-key-id' }).should.be.true();
+                mockBitGo.decrypt.calledWith({ input: encryptedPrv, password: walletPassphrase }).should.be.true();
+                mockBaseCoin.signMessage.calledOnce.should.be.true();
+                result.should.equal(Buffer.from(signature, 'hex').toString('hex'));
+            });
+            it('should stringify a Record payload before signing locally', async function () {
+                await tradingAccount.signPayload({ payload, walletPassphrase });
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[1].should.equal(JSON.stringify(payload));
+            });
+            it('should pass a string payload directly to signMessage', async function () {
+                await tradingAccount.signPayload({ payload: payloadString, walletPassphrase });
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[1].should.equal(payloadString);
+            });
+        });
+        describe('with both walletPassphrase and prv', function () {
+            it('should use prv directly and not call decrypt when both are provided', async function () {
+                await tradingAccount.signPayload({ payload, walletPassphrase, prv: decryptedPrv });
+                mockBitGo.decrypt.called.should.be.false();
+                mockBaseCoin.keychains.called.should.be.false();
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[0].should.deepEqual({ prv: decryptedPrv });
+            });
+        });
+        describe('with prv (local user key signing without decryption)', function () {
+            it('should sign using the provided prv without calling decrypt', async function () {
+                const result = await tradingAccount.signPayload({ payload, prv: decryptedPrv });
+                mockBitGo.decrypt.called.should.be.false();
+                mockBaseCoin.keychains.called.should.be.false();
+                mockBaseCoin.signMessage.calledOnce.should.be.true();
+                result.should.equal(Buffer.from(signature, 'hex').toString('hex'));
+            });
+            it('should not use BitGo remote signing when prv is provided', async function () {
+                await tradingAccount.signPayload({ payload, prv: decryptedPrv });
+                mockBitGo.post.called.should.be.false();
+            });
+            it('should pass the prv directly to signMessage', async function () {
+                await tradingAccount.signPayload({ payload, prv: decryptedPrv });
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[0].should.deepEqual({ prv: decryptedPrv });
+            });
+            it('should stringify a Record payload before signing with prv', async function () {
+                await tradingAccount.signPayload({ payload, prv: decryptedPrv });
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[1].should.equal(JSON.stringify(payload));
+            });
+            it('should pass a string payload directly to signMessage when signing with prv', async function () {
+                await tradingAccount.signPayload({ payload: payloadString, prv: decryptedPrv });
+                const signMessageCall = mockBaseCoin.signMessage.getCall(0);
+                signMessageCall.args[1].should.equal(payloadString);
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tradingAccount.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/trading/tradingAccount.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\nimport sinon from 'sinon';\nimport 'should';\nimport { TradingAccount } from '../../../../src/bitgo/trading/tradingAccount';\n\ndescribe('TradingAccount', function () {\n  let tradingAccount: TradingAccount;\n  let userKeyRequiredTradingAccount: TradingAccount;\n  let mockBitGo: any;\n  let mockWallet: any;\n  let mockUserKeyRequiredWallet: any;\n  let mockBaseCoin: any;\n  let sendStub: sinon.SinonStub;\n\n  const enterpriseId = 'test-enterprise-id';\n  const walletPassphrase = 'test-passphrase';\n  const encryptedPrv = 'encrypted-prv';\n  const decryptedPrv = 'decrypted-prv';\n  const signature = 'aabbccdd';\n  const payload = { data: 'test-payload' };\n  const payloadString = JSON.stringify(payload);\n\n  beforeEach(function () {\n    sendStub = sinon.stub();\n    sendStub.withArgs({ payload: payloadString }).returns({ result: sinon.stub().resolves({ signature }) });\n\n    mockBitGo = {\n      post: sinon.stub().returns({ send: sendStub }),\n      coin: sinon.stub().callsFake((coin: string) => ({\n        url: sinon.stub().callsFake((url: string) => `https://app.bitgo-staging.com/api/v2/${coin}${url}`),\n      })),\n      decrypt: sinon\n        .stub()\n        .callsFake(async ({ input, password }) =>\n          input === encryptedPrv && password === walletPassphrase ? decryptedPrv : undefined\n        ),\n    };\n\n    mockBaseCoin = {\n      keychains: sinon.stub().returns({\n        get: sinon.stub().resolves({ encryptedPrv }),\n      }),\n      signMessage: sinon.stub().callsFake(async (key: { prv: string }) => {\n        if (key.prv === decryptedPrv) {\n          return Buffer.from(signature, 'hex');\n        }\n        throw new Error(`signMessage called with unexpected prv: ${key.prv}`);\n      }),\n    };\n\n    mockWallet = {\n      id: sinon.stub().returns('test-wallet-id'),\n      keyIds: sinon.stub().returns(['user-key-id', 'bitgo-key-id']),\n      toJSON: sinon.stub().returns({\n        id: 'test-wallet-id',\n        keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],\n        coinSpecific: {\n          userKeySigningRequired: false,\n        },\n      }),\n      baseCoin: mockBaseCoin,\n      bitgo: mockBitGo,\n    };\n\n    mockUserKeyRequiredWallet = {\n      ...mockWallet,\n      toJSON: sinon.stub().returns({\n        id: 'test-wallet-id',\n        keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],\n        coinSpecific: {\n          userKeySigningRequired: true,\n        },\n      }),\n    };\n\n    tradingAccount = new TradingAccount(enterpriseId, mockWallet, mockBitGo);\n    userKeyRequiredTradingAccount = new TradingAccount(enterpriseId, mockUserKeyRequiredWallet, mockBitGo);\n  });\n\n  afterEach(function () {\n    sinon.restore();\n  });\n\n  describe('id', function () {\n    it('should return the wallet id', function () {\n      tradingAccount.id.should.equal('test-wallet-id');\n      mockWallet.id.calledOnce.should.be.true();\n    });\n  });\n\n  describe('signPayload', function () {\n    it('should call the right url', async function () {\n      const expectedUrl = `https://app.bitgo-staging.com/api/v2/ofc/wallet/test-wallet-id/tx/sign`;\n      await tradingAccount.signPayload({ payload });\n      mockBitGo.post.calledWith(expectedUrl).should.be.true();\n    });\n\n    describe('without walletPassphrase or prv (BitGo remote signing)', function () {\n      it('should sign using the BitGo key remotely when no passphrase is provided', async function () {\n        const result = await tradingAccount.signPayload({ payload });\n\n        mockBitGo.post.calledOnce.should.be.true();\n        sendStub.calledWith({ payload: JSON.stringify(payload) }).should.be.true();\n        result.should.equal(signature);\n      });\n\n      it('should sign a string payload remotely when no passphrase is provided', async function () {\n        const result = await tradingAccount.signPayload({ payload: payloadString });\n        sendStub.calledWith({ payload: payloadString }).should.be.true();\n        result.should.equal(signature);\n      });\n\n      it('should throw if coinSpecific.userKeySigningRequired is true and no passphrase and prv are provided', async function () {\n        await userKeyRequiredTradingAccount\n          .signPayload({ payload })\n          .should.be.rejectedWith(\n            'Wallet must use user key to sign ofc transaction, please provide the wallet passphrase, the private key, or visit your wallet settings page to configure one.'\n          );\n      });\n\n      it('should fall back to top-level userKeySigningRequired when coinSpecific does not carry it', async function () {\n        await userKeyRequiredTradingAccount\n          .signPayload({ payload })\n          .should.be.rejectedWith(\n            'Wallet must use user key to sign ofc transaction, please provide the wallet passphrase, the private key, or visit your wallet settings page to configure one.'\n          );\n      });\n\n      it('should prefer coinSpecific.userKeySigningRequired over top-level when both are present', async function () {\n        mockWallet.toJSON.onCall(mockWallet.toJSON.callCount).returns({\n          id: 'test-wallet-id',\n          keys: ['user-key-id', 'backup-key-id', 'bitgo-key-id'],\n          coinSpecific: { userKeySigningRequired: false },\n          userKeySigningRequired: true,\n        });\n\n        const result = await tradingAccount.signPayload({ payload });\n        result.should.equal(signature);\n      });\n\n      it('should throw if wallet has fewer than 2 keys and no passphrase and prv are provided', async function () {\n        mockWallet.toJSON.onCall(mockWallet.toJSON.callCount).returns({\n          id: 'test-wallet-id',\n          keys: ['user-key-id'],\n          coinSpecific: {},\n        });\n\n        await tradingAccount\n          .signPayload({ payload })\n          .should.be.rejectedWith(\n            'Wallet does not support BitGo signing. Please reach out to support@bitgo.com to resolve this issue.'\n          );\n      });\n    });\n\n    describe('with walletPassphrase (local user key signing)', function () {\n      it('should decrypt the user key and sign the payload locally', async function () {\n        const result = await tradingAccount.signPayload({ payload, walletPassphrase });\n\n        mockBaseCoin.keychains().get.calledWith({ id: 'user-key-id' }).should.be.true();\n        mockBitGo.decrypt.calledWith({ input: encryptedPrv, password: walletPassphrase }).should.be.true();\n        mockBaseCoin.signMessage.calledOnce.should.be.true();\n        result.should.equal(Buffer.from(signature, 'hex').toString('hex'));\n      });\n\n      it('should stringify a Record payload before signing locally', async function () {\n        await tradingAccount.signPayload({ payload, walletPassphrase });\n\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[1].should.equal(JSON.stringify(payload));\n      });\n\n      it('should pass a string payload directly to signMessage', async function () {\n        await tradingAccount.signPayload({ payload: payloadString, walletPassphrase });\n\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[1].should.equal(payloadString);\n      });\n    });\n\n    describe('with both walletPassphrase and prv', function () {\n      it('should use prv directly and not call decrypt when both are provided', async function () {\n        await tradingAccount.signPayload({ payload, walletPassphrase, prv: decryptedPrv });\n\n        mockBitGo.decrypt.called.should.be.false();\n        mockBaseCoin.keychains.called.should.be.false();\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[0].should.deepEqual({ prv: decryptedPrv });\n      });\n    });\n\n    describe('with prv (local user key signing without decryption)', function () {\n      it('should sign using the provided prv without calling decrypt', async function () {\n        const result = await tradingAccount.signPayload({ payload, prv: decryptedPrv });\n\n        mockBitGo.decrypt.called.should.be.false();\n        mockBaseCoin.keychains.called.should.be.false();\n        mockBaseCoin.signMessage.calledOnce.should.be.true();\n        result.should.equal(Buffer.from(signature, 'hex').toString('hex'));\n      });\n\n      it('should not use BitGo remote signing when prv is provided', async function () {\n        await tradingAccount.signPayload({ payload, prv: decryptedPrv });\n\n        mockBitGo.post.called.should.be.false();\n      });\n\n      it('should pass the prv directly to signMessage', async function () {\n        await tradingAccount.signPayload({ payload, prv: decryptedPrv });\n\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[0].should.deepEqual({ prv: decryptedPrv });\n      });\n\n      it('should stringify a Record payload before signing with prv', async function () {\n        await tradingAccount.signPayload({ payload, prv: decryptedPrv });\n\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[1].should.equal(JSON.stringify(payload));\n      });\n\n      it('should pass a string payload directly to signMessage when signing with prv', async function () {\n        await tradingAccount.signPayload({ payload: payloadString, prv: decryptedPrv });\n\n        const signMessageCall = mockBaseCoin.signMessage.getCall(0);\n        signMessageCall.args[1].should.equal(payloadString);\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/tss/bitgoPubKeys.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=bitgoPubKeys.d.ts.map

package/dist/test/unit/bitgo/tss/bitgoPubKeys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bitgoPubKeys.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/tss/bitgoPubKeys.ts"],"names":[],"mappings":""}

package/dist/test/unit/bitgo/tss/bitgoPubKeys.js

@@ -0,0 +1,66 @@
+"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 assert = __importStar(require("assert"));
+const bitgoPubKeys_1 = require("../../../../src/bitgo/tss/bitgoPubKeys");
+describe('bitgoPubKeys RedPallas MPCv2 key config', function () {
+    it('getBitgoMpcGpgPubKey returns a key for redpallasMpcv2 across env/hsmType combos', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('test', 'nitro', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('prod', 'nitro', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.prod);
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('test', 'onprem', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.onprem.test);
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('prod', 'onprem', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.onprem.prod);
+    });
+    it('non-prod/non-adminProd envs default to the test key for redpallasMpcv2', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('staging', 'nitro', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test);
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('adminTest', 'onprem', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.onprem.test);
+    });
+    it('adminProd resolves to the prod key for redpallasMpcv2', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('adminProd', 'nitro', 'redpallasMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.prod);
+    });
+    it('isBitgoRedpallasMpcv2PubKey identifies known redpallasMpcv2 keys', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoRedpallasMpcv2PubKey)(bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test), true);
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoRedpallasMpcv2PubKey)(bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.onprem.prod), true);
+    });
+    it('isBitgoRedpallasMpcv2PubKey rejects keys from other mpc versions', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoRedpallasMpcv2PubKey)(bitgoPubKeys_1.bitgoMpcGpgPubKeys.mpcv1.nitro.test), false);
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoRedpallasMpcv2PubKey)('not-a-real-key'), false);
+    });
+    it('does not affect eddsaMpcv2 key lookups', function () {
+        assert.strictEqual((0, bitgoPubKeys_1.getBitgoMpcGpgPubKey)('test', 'nitro', 'eddsaMpcv2'), bitgoPubKeys_1.bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test);
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoEddsaMpcv2PubKey)(bitgoPubKeys_1.bitgoMpcGpgPubKeys.eddsaMpcv2.nitro.test), true);
+        assert.strictEqual((0, bitgoPubKeys_1.isBitgoEddsaMpcv2PubKey)(bitgoPubKeys_1.bitgoMpcGpgPubKeys.redpallasMpcv2.nitro.test), true); // interim: same key material
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/test/unit/bitgo/utils/abstractUtxoCoinUtil.js

@@ -8,18 +8,59 @@ const src_1 = require("../../../../src");
 describe('getUtxoCoinScriptTypes', function () {
     it('success', function () {
         const fn = (coin, arr) => {
-            const scriptTypes = src_1.getUtxoCoinScriptTypes2Of3(coin);
+            const scriptTypes = (0, src_1.getUtxoCoinScriptTypes2Of3)(coin);
             return arr.find((v) => scriptTypes.includes(v));
         };
         assert_1.default.ok(fn('btc', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));
         assert_1.default.ok(fn('ltc', ['p2sh', 'p2shP2wsh', 'p2wsh']));
         assert_1.default.ok(fn('doge', ['p2sh']));
     });
+    it('fail with an actionable message for wasm-only coins', function () {
+        // pearl is served through @bitgo/wasm-utxo and has no utxo-lib network, so its
+        // utxolibName does not resolve here. Assert the guidance rather than letting it
+        // fall through to a bare `TypeError: invalid network`.
+        for (const coinName of ['pearl', 'tpearl']) {
+            assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)(coinName), (e) => /has no utxo-lib network/.test(e.message) && /@bitgo\/wasm-utxo/.test(e.message));
+        }
+    });
+    it('fail for invalid coin name', function () {
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)('dummy'), (e) => e.message === `coin 'dummy' is not defined`);
+    });
+    it('fail for non-utxo coin name', function () {
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypes2Of3)('eth'), (e) => e.message === 'coin eth is not a utxo coin');
+    });
+});
+describe('getUtxoCoinScriptTypesForWalletType', function () {
+    it('success', function () {
+        const fn = (coin, walletType, arr) => {
+            const scriptTypes = (0, src_1.getUtxoCoinScriptTypesForWalletType)(coin, walletType);
+            return arr.find((v) => scriptTypes.includes(v));
+        };
+        assert_1.default.ok(fn('btc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));
+        assert_1.default.ok(fn('btc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr']));
+        assert_1.default.ok(fn('ltc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh']));
+        assert_1.default.ok(fn('ltc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh']));
+        assert_1.default.ok(fn('doge', 'hot', ['p2sh']));
+        assert_1.default.ok(fn('doge', 'cold', ['p2sh']));
+    });
+    it('applies the wallet-type rule for p2trMusig2', function () {
+        // p2trMusig2 is hot-only on mainnet; cold is allowed on testnet
+        assert_1.default.ok((0, src_1.getUtxoCoinScriptTypesForWalletType)('btc', 'hot').includes('p2trMusig2'));
+        assert_1.default.ok(!(0, src_1.getUtxoCoinScriptTypesForWalletType)('btc', 'cold').includes('p2trMusig2'));
+        assert_1.default.ok((0, src_1.getUtxoCoinScriptTypesForWalletType)('tbtc', 'cold').includes('p2trMusig2'));
+    });
+    it('fail with an actionable message for wasm-only coins', function () {
+        for (const coinName of ['pearl', 'tpearl']) {
+            for (const walletType of ['hot', 'cold']) {
+                assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)(coinName, walletType), (e) => /has no utxo-lib network/.test(e.message) && /@bitgo\/wasm-utxo/.test(e.message));
+            }
+        }
+    });
     it('fail for invalid coin name', function () {
-        assert_1.default.throws(() => src_1.getUtxoCoinScriptTypes2Of3('dummy'), (e) => e.message === `coin 'dummy' is not defined`);
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)('dummy', 'hot'), (e) => e.message === `coin 'dummy' is not defined`);
     });
     it('fail for non-utxo coin name', function () {
-        assert_1.default.throws(() => src_1.getUtxoCoinScriptTypes2Of3('eth'), (e) => e.message === 'coin eth is not a utxo coin');
+        assert_1.default.throws(() => (0, src_1.getUtxoCoinScriptTypesForWalletType)('eth', 'hot'), (e) => e.message === 'coin eth is not a utxo coin');
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"abstractUtxoCoinUtil.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/abstractUtxoCoinUtil.ts"],"names":[],"mappings":";;;;;AAAA,oDAA4B;AAE5B,yCAAkG;AAGlG,QAAQ,CAAC,wBAAwB,EAAE;IACjC,EAAE,CAAC,SAAS,EAAE;QACZ,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,GAAiD,EAAE,EAAE;YAC7E,MAAM,WAAW,GAAG,IAAA,gCAA0B,EAAC,IAAI,CAAC,CAAC;YACrD,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC;QACF,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;QAC3E,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QACrD,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAClC,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE;QACxD,+EAA+E;QAC/E,gFAAgF;QAChF,uDAAuD;QACvD,KAAK,MAAM,QAAQ,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC3C,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,gCAA0B,EAAC,QAAQ,CAAC,EAC1C,CAAC,CAAM,EAAE,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAC7F,CAAC;QACJ,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE;QAC/B,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,gCAA0B,EAAC,OAAO,CAAC,EACzC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,6BAA6B,CACxD,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6BAA6B,EAAE;QAChC,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,gCAA0B,EAAC,KAAK,CAAC,EACvC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,6BAA6B,CACxD,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC;AAEH,QAAQ,CAAC,qCAAqC,EAAE;IAC9C,EAAE,CAAC,SAAS,EAAE;QACZ,MAAM,EAAE,GAAG,CAAC,IAAY,EAAE,UAA0B,EAAE,GAAiD,EAAE,EAAE;YACzG,MAAM,WAAW,GAAG,IAAA,yCAAmC,EAAC,IAAI,EAAE,UAAU,CAAC,CAAC;YAC1E,OAAO,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;QAClD,CAAC,CAAC;QACF,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,CAAC;QAClF,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;QACrE,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QAC5D,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC;QAC7D,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;QACvC,gBAAM,CAAC,EAAE,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC;IAC1C,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6CAA6C,EAAE;QAChD,gEAAgE;QAChE,gBAAM,CAAC,EAAE,CAAC,IAAA,yCAAmC,EAAC,KAAK,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;QACpF,gBAAM,CAAC,EAAE,CAAC,CAAC,IAAA,yCAAmC,EAAC,KAAK,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;QACtF,gBAAM,CAAC,EAAE,CAAC,IAAA,yCAAmC,EAAC,MAAM,EAAE,MAAM,CAAC,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,CAAC;IACxF,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,qDAAqD,EAAE;QACxD,KAAK,MAAM,QAAQ,IAAI,CAAC,OAAO,EAAE,QAAQ,CAAC,EAAE,CAAC;YAC3C,KAAK,MAAM,UAAU,IAAI,CAAC,KAAK,EAAE,MAAM,CAAU,EAAE,CAAC;gBAClD,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,yCAAmC,EAAC,QAAQ,EAAE,UAAU,CAAC,EAC/D,CAAC,CAAM,EAAE,EAAE,CAAC,yBAAyB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,IAAI,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAC7F,CAAC;YACJ,CAAC;QACH,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,4BAA4B,EAAE;QAC/B,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,yCAAmC,EAAC,OAAO,EAAE,KAAK,CAAC,EACzD,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,6BAA6B,CACxD,CAAC;IACJ,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,6BAA6B,EAAE;QAChC,gBAAM,CAAC,MAAM,CACX,GAAG,EAAE,CAAC,IAAA,yCAAmC,EAAC,KAAK,EAAE,KAAK,CAAC,EACvD,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,KAAK,6BAA6B,CACxD,CAAC;IACJ,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC","sourcesContent":["import assert from 'assert';\n\nimport { getUtxoCoinScriptTypes2Of3, getUtxoCoinScriptTypesForWalletType } from '../../../../src';\nimport * as utxolib from '@bitgo-beta/utxo-lib';\n\ndescribe('getUtxoCoinScriptTypes', function () {\n  it('success', function () {\n    const fn = (coin: string, arr: utxolib.bitgo.outputScripts.ScriptType2Of3[]) => {\n      const scriptTypes = getUtxoCoinScriptTypes2Of3(coin);\n      return arr.find((v) => scriptTypes.includes(v));\n    };\n    assert.ok(fn('btc', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));\n    assert.ok(fn('ltc', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('doge', ['p2sh']));\n  });\n\n  it('fail with an actionable message for wasm-only coins', function () {\n    // pearl is served through @bitgo/wasm-utxo and has no utxo-lib network, so its\n    // utxolibName does not resolve here. Assert the guidance rather than letting it\n    // fall through to a bare `TypeError: invalid network`.\n    for (const coinName of ['pearl', 'tpearl']) {\n      assert.throws(\n        () => getUtxoCoinScriptTypes2Of3(coinName),\n        (e: any) => /has no utxo-lib network/.test(e.message) && /@bitgo\\/wasm-utxo/.test(e.message)\n      );\n    }\n  });\n\n  it('fail for invalid coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypes2Of3('dummy'),\n      (e: any) => e.message === `coin 'dummy' is not defined`\n    );\n  });\n\n  it('fail for non-utxo coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypes2Of3('eth'),\n      (e: any) => e.message === 'coin eth is not a utxo coin'\n    );\n  });\n});\n\ndescribe('getUtxoCoinScriptTypesForWalletType', function () {\n  it('success', function () {\n    const fn = (coin: string, walletType: 'hot' | 'cold', arr: utxolib.bitgo.outputScripts.ScriptType2Of3[]) => {\n      const scriptTypes = getUtxoCoinScriptTypesForWalletType(coin, walletType);\n      return arr.find((v) => scriptTypes.includes(v));\n    };\n    assert.ok(fn('btc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr', 'p2trMusig2']));\n    assert.ok(fn('btc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh', 'p2tr']));\n    assert.ok(fn('ltc', 'hot', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('ltc', 'cold', ['p2sh', 'p2shP2wsh', 'p2wsh']));\n    assert.ok(fn('doge', 'hot', ['p2sh']));\n    assert.ok(fn('doge', 'cold', ['p2sh']));\n  });\n\n  it('applies the wallet-type rule for p2trMusig2', function () {\n    // p2trMusig2 is hot-only on mainnet; cold is allowed on testnet\n    assert.ok(getUtxoCoinScriptTypesForWalletType('btc', 'hot').includes('p2trMusig2'));\n    assert.ok(!getUtxoCoinScriptTypesForWalletType('btc', 'cold').includes('p2trMusig2'));\n    assert.ok(getUtxoCoinScriptTypesForWalletType('tbtc', 'cold').includes('p2trMusig2'));\n  });\n\n  it('fail with an actionable message for wasm-only coins', function () {\n    for (const coinName of ['pearl', 'tpearl']) {\n      for (const walletType of ['hot', 'cold'] as const) {\n        assert.throws(\n          () => getUtxoCoinScriptTypesForWalletType(coinName, walletType),\n          (e: any) => /has no utxo-lib network/.test(e.message) && /@bitgo\\/wasm-utxo/.test(e.message)\n        );\n      }\n    }\n  });\n\n  it('fail for invalid coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypesForWalletType('dummy', 'hot'),\n      (e: any) => e.message === `coin 'dummy' is not defined`\n    );\n  });\n\n  it('fail for non-utxo coin name', function () {\n    assert.throws(\n      () => getUtxoCoinScriptTypesForWalletType('eth', 'hot'),\n      (e: any) => e.message === 'coin eth is not a utxo coin'\n    );\n  });\n});\n"]}

package/dist/test/unit/bitgo/utils/messageTypes.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=messageTypes.d.ts.map

package/dist/test/unit/bitgo/utils/messageTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageTypes.d.ts","sourceRoot":"","sources":["../../../../../test/unit/bitgo/utils/messageTypes.ts"],"names":[],"mappings":""}