@bitgo-beta/sdk-core 8.2.1-beta.172 → 8.2.1-beta.1721

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

@@ -0,0 +1,262 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const errors_1 = require("../../../src/bitgo/errors");
+describe('Transaction Intent Mismatch Errors', () => {
+    const mockTransactionId = '0x1234567890abcdef';
+    const mockTxParams = [
+        { recipients: [{ address: '0xrecipient1', amount: '1000000000000000000' }] },
+        { recipients: [{ address: '0xrecipient2', amount: '2000000000000000000' }] },
+    ];
+    const mockTxHex = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';
+    describe('TxIntentMismatchError', () => {
+        it('should create base transaction intent mismatch error with all required properties', () => {
+            const message = 'Transaction does not match user intent';
+            const error = new errors_1.TxIntentMismatchError(message, mockTransactionId, mockTxParams, mockTxHex);
+            should_1.default.exist(error);
+            should_1.default.equal(error.message, message);
+            should_1.default.equal(error.name, 'TxIntentMismatchError');
+            should_1.default.equal(error.id, mockTransactionId);
+            should_1.default.deepEqual(error.txParams, mockTxParams);
+            should_1.default.equal(error.txHex, mockTxHex);
+            should_1.default.equal(error.txExplanation, undefined); // txExplanation is optional
+        });
+        it('should create error with txExplanation when provided', () => {
+            const message = 'Transaction does not match user intent';
+            const txExplanationObj = {
+                id: '0xtxid',
+                outputAmount: '1000000',
+                outputs: [{ address: '0xrecipient', amount: '1000000' }],
+                fee: { fee: '21000' },
+            };
+            const error = new errors_1.TxIntentMismatchError(message, mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);
+            should_1.default.exist(error);
+            // Should be stringified
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            const parsed = JSON.parse(error.txExplanation);
+            should_1.default.equal(parsed.id, '0xtxid');
+            should_1.default.equal(parsed.outputAmount, '1000000');
+        });
+        it('should be an instance of Error', () => {
+            const error = new errors_1.TxIntentMismatchError('Test message', mockTransactionId, mockTxParams, mockTxHex);
+            (0, should_1.default)(error).be.instanceOf(Error);
+        });
+    });
+    describe('TxIntentMismatchRecipientError', () => {
+        it('should create recipient intent mismatch error with mismatched recipients', () => {
+            const message = 'Transaction recipients do not match user intent';
+            const mismatchedRecipients = [
+                { address: '0xexpected1', amount: '1000' },
+                { address: '0xexpected2', amount: '2000' },
+            ];
+            const error = new errors_1.TxIntentMismatchRecipientError(message, mockTransactionId, mockTxParams, mockTxHex, mismatchedRecipients);
+            should_1.default.exist(error);
+            should_1.default.equal(error.message, message);
+            should_1.default.equal(error.name, 'TxIntentMismatchRecipientError');
+            should_1.default.equal(error.id, mockTransactionId);
+            should_1.default.deepEqual(error.txParams, mockTxParams);
+            should_1.default.equal(error.txHex, mockTxHex);
+            should_1.default.deepEqual(error.mismatchedRecipients, mismatchedRecipients);
+            should_1.default.equal(error.txExplanation, undefined); // txExplanation is optional
+        });
+        it('should create recipient error with txExplanation when provided', () => {
+            const message = 'Transaction recipients do not match user intent';
+            const mismatchedRecipients = [{ address: '0xexpected1', amount: '1000' }];
+            const txExplanationObj = {
+                id: '0xtxid',
+                outputs: [{ address: '0xactual', amount: '1000' }],
+            };
+            const error = new errors_1.TxIntentMismatchRecipientError(message, mockTransactionId, mockTxParams, mockTxHex, mismatchedRecipients, txExplanationObj);
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            const parsed = JSON.parse(error.txExplanation);
+            should_1.default.equal(parsed.id, '0xtxid');
+            should_1.default.deepEqual(error.mismatchedRecipients, mismatchedRecipients);
+        });
+        it('should be an instance of TxIntentMismatchError', () => {
+            const error = new errors_1.TxIntentMismatchRecipientError('Test message', mockTransactionId, mockTxParams, mockTxHex, []);
+            (0, should_1.default)(error).be.instanceOf(errors_1.TxIntentMismatchError);
+            (0, should_1.default)(error).be.instanceOf(Error);
+        });
+    });
+    describe('TxIntentMismatchContractError', () => {
+        it('should create contract intent mismatch error with mismatched data payload', () => {
+            const message = 'Contract interaction does not match user intent';
+            const mismatchedDataPayload = {
+                address: '0xcontract123',
+                rawContractPayload: '0xabcdef',
+                decodedContractPayload: { method: 'transfer', params: ['0xrecipient', '1000'] },
+            };
+            const error = new errors_1.TxIntentMismatchContractError(message, mockTransactionId, mockTxParams, mockTxHex, mismatchedDataPayload);
+            should_1.default.exist(error);
+            should_1.default.equal(error.message, message);
+            should_1.default.equal(error.name, 'TxIntentMismatchContractError');
+            should_1.default.equal(error.id, mockTransactionId);
+            should_1.default.deepEqual(error.txParams, mockTxParams);
+            should_1.default.equal(error.txHex, mockTxHex);
+            should_1.default.deepEqual(error.mismatchedDataPayload, mismatchedDataPayload);
+            should_1.default.equal(error.txExplanation, undefined); // txExplanation is optional
+        });
+        it('should create contract error with txExplanation when provided', () => {
+            const message = 'Contract interaction does not match user intent';
+            const mismatchedDataPayload = {
+                address: '0xcontract123',
+                rawContractPayload: '0xabcdef',
+                decodedContractPayload: { method: 'approve', params: ['0xspender', 'unlimited'] },
+            };
+            const txExplanationObj = {
+                id: '0xtxid',
+                outputs: [{ address: '0xcontract123', amount: '0' }],
+                contractCall: { method: 'approve', params: ['0xspender', 'unlimited'] },
+            };
+            const error = new errors_1.TxIntentMismatchContractError(message, mockTransactionId, mockTxParams, mockTxHex, mismatchedDataPayload, txExplanationObj);
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            const parsed = JSON.parse(error.txExplanation);
+            should_1.default.equal(parsed.id, '0xtxid');
+            should_1.default.deepEqual(error.mismatchedDataPayload, mismatchedDataPayload);
+        });
+        it('should be an instance of TxIntentMismatchError', () => {
+            const error = new errors_1.TxIntentMismatchContractError('Test message', mockTransactionId, mockTxParams, mockTxHex, {
+                address: '0xtest',
+                rawContractPayload: '0x',
+                decodedContractPayload: {},
+            });
+            (0, should_1.default)(error).be.instanceOf(errors_1.TxIntentMismatchError);
+            (0, should_1.default)(error).be.instanceOf(Error);
+        });
+    });
+    describe('TxIntentMismatchApprovalError', () => {
+        it('should create approval intent mismatch error with token approval details', () => {
+            const message = 'Token approval does not match user intent';
+            const tokenApproval = {
+                tokenName: 'TestToken',
+                tokenAddress: '0xtoken123',
+                authorizingAmount: { type: 'unlimited' },
+                authorizingAddress: '0xspender456',
+            };
+            const error = new errors_1.TxIntentMismatchApprovalError(message, mockTransactionId, mockTxParams, mockTxHex, tokenApproval);
+            should_1.default.exist(error);
+            should_1.default.equal(error.message, message);
+            should_1.default.equal(error.name, 'TxIntentMismatchApprovalError');
+            should_1.default.equal(error.id, mockTransactionId);
+            should_1.default.deepEqual(error.txParams, mockTxParams);
+            should_1.default.equal(error.txHex, mockTxHex);
+            should_1.default.deepEqual(error.tokenApproval, tokenApproval);
+            should_1.default.equal(error.txExplanation, undefined); // txExplanation is optional
+        });
+        it('should create approval error with txExplanation when provided', () => {
+            const message = 'Token approval does not match user intent';
+            const tokenApproval = {
+                tokenName: 'USDC',
+                tokenAddress: '0xusdc',
+                authorizingAmount: { type: 'unlimited' },
+                authorizingAddress: '0xmalicious',
+            };
+            const txExplanationObj = {
+                id: '0xtxid',
+                outputs: [{ address: '0xusdc', amount: '0' }],
+                tokenApproval: {
+                    token: 'USDC',
+                    spender: '0xmalicious',
+                    amount: 'unlimited',
+                },
+            };
+            const error = new errors_1.TxIntentMismatchApprovalError(message, mockTransactionId, mockTxParams, mockTxHex, tokenApproval, txExplanationObj);
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            const parsed = JSON.parse(error.txExplanation);
+            should_1.default.equal(parsed.id, '0xtxid');
+            should_1.default.deepEqual(error.tokenApproval, tokenApproval);
+        });
+        it('should be an instance of TxIntentMismatchError', () => {
+            const error = new errors_1.TxIntentMismatchApprovalError('Test message', mockTransactionId, mockTxParams, mockTxHex, {
+                tokenAddress: '0xtoken',
+                authorizingAmount: { type: 'limited', amount: 1000 },
+                authorizingAddress: '0xspender',
+            });
+            (0, should_1.default)(error).be.instanceOf(errors_1.TxIntentMismatchError);
+            (0, should_1.default)(error).be.instanceOf(Error);
+        });
+    });
+    describe('Error inheritance and properties', () => {
+        it('should maintain proper inheritance chain', () => {
+            const baseError = new errors_1.TxIntentMismatchError('Base error', mockTransactionId, mockTxParams, mockTxHex);
+            const recipientError = new errors_1.TxIntentMismatchRecipientError('Recipient error', mockTransactionId, mockTxParams, mockTxHex, []);
+            const contractError = new errors_1.TxIntentMismatchContractError('Contract error', mockTransactionId, mockTxParams, mockTxHex, { address: '0xtest', rawContractPayload: '0x', decodedContractPayload: {} });
+            const approvalError = new errors_1.TxIntentMismatchApprovalError('Approval error', mockTransactionId, mockTxParams, mockTxHex, {
+                tokenAddress: '0xtoken',
+                authorizingAmount: { type: 'limited', amount: 1000 },
+                authorizingAddress: '0xspender',
+            });
+            // All should be instances of Error
+            (0, should_1.default)(baseError).be.instanceOf(Error);
+            (0, should_1.default)(recipientError).be.instanceOf(Error);
+            (0, should_1.default)(contractError).be.instanceOf(Error);
+            (0, should_1.default)(approvalError).be.instanceOf(Error);
+            // All should be instances of TxIntentMismatchError
+            (0, should_1.default)(recipientError).be.instanceOf(errors_1.TxIntentMismatchError);
+            (0, should_1.default)(contractError).be.instanceOf(errors_1.TxIntentMismatchError);
+            (0, should_1.default)(approvalError).be.instanceOf(errors_1.TxIntentMismatchError);
+        });
+        it('should preserve stack trace', () => {
+            const error = new errors_1.TxIntentMismatchError('Test error', mockTransactionId, mockTxParams, mockTxHex);
+            should_1.default.exist(error.stack);
+            (0, should_1.default)(error.stack).be.a.String();
+            (0, should_1.default)(error.stack).containEql('TxIntentMismatchError');
+        });
+    });
+    describe('Transaction explanation property', () => {
+        it('should handle valid JSON transaction explanations', () => {
+            const txExplanationObj = {
+                id: '0x123abc',
+                outputAmount: '1000000000000000000',
+                outputs: [
+                    { address: '0xrecipient1', amount: '500000000000000000' },
+                    { address: '0xrecipient2', amount: '500000000000000000' },
+                ],
+                fee: { fee: '21000', gasLimit: '21000' },
+                type: 'send',
+            };
+            const error = new errors_1.TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            // Verify it can be parsed back
+            const parsed = JSON.parse(error.txExplanation);
+            should_1.default.equal(parsed.id, '0x123abc');
+            should_1.default.equal(parsed.outputs.length, 2);
+        });
+        it('should handle empty transaction explanation', () => {
+            const error = new errors_1.TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, undefined);
+            should_1.default.equal(error.txExplanation, undefined);
+        });
+        it('should handle BigInt values in transaction explanation', () => {
+            const txExplanationObj = {
+                id: '0x123',
+                outputAmount: BigInt('9007199254740992'),
+                changeAmount: BigInt('1234567890123456789'),
+                outputs: [{ address: 'addr1', amount: BigInt('9007199254740992') }],
+            };
+            const error = new errors_1.TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);
+            should_1.default.equal(typeof error.txExplanation, 'string');
+            const parsed = JSON.parse(error.txExplanation);
+            // BigInts should be converted to strings
+            should_1.default.equal(parsed.outputAmount, '9007199254740992');
+            should_1.default.equal(parsed.changeAmount, '1234567890123456789');
+            should_1.default.equal(parsed.outputs[0].amount, '9007199254740992');
+        });
+        it('should work with all error subclasses', () => {
+            const txExplanationObj = { id: '0x123', outputs: [] };
+            const errors = [
+                new errors_1.TxIntentMismatchRecipientError('Test', mockTransactionId, mockTxParams, mockTxHex, [], txExplanationObj),
+                new errors_1.TxIntentMismatchContractError('Test', mockTransactionId, mockTxParams, mockTxHex, { address: '0x', rawContractPayload: '0x', decodedContractPayload: {} }, txExplanationObj),
+                new errors_1.TxIntentMismatchApprovalError('Test', mockTransactionId, mockTxParams, mockTxHex, { tokenAddress: '0x', authorizingAmount: { type: 'limited', amount: 0 }, authorizingAddress: '0x' }, txExplanationObj),
+            ];
+            errors.forEach((error) => {
+                should_1.default.equal(typeof error.txExplanation, 'string');
+                const parsed = JSON.parse(error.txExplanation);
+                should_1.default.equal(parsed.id, '0x123');
+            });
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"errors.js","sourceRoot":"","sources":["../../../../test/unit/bitgo/errors.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport {\n  TxIntentMismatchError,\n  TxIntentMismatchRecipientError,\n  TxIntentMismatchContractError,\n  TxIntentMismatchApprovalError,\n  MismatchedRecipient,\n  ContractDataPayload,\n  TokenApproval,\n} from '../../../src/bitgo/errors';\nimport { TransactionParams } from '../../../src/bitgo/baseCoin';\n\ndescribe('Transaction Intent Mismatch Errors', () => {\n  const mockTransactionId = '0x1234567890abcdef';\n  const mockTxParams: TransactionParams[] = [\n    { recipients: [{ address: '0xrecipient1', amount: '1000000000000000000' }] },\n    { recipients: [{ address: '0xrecipient2', amount: '2000000000000000000' }] },\n  ];\n  const mockTxHex = '0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef';\n\n  describe('TxIntentMismatchError', () => {\n    it('should create base transaction intent mismatch error with all required properties', () => {\n      const message = 'Transaction does not match user intent';\n      const error = new TxIntentMismatchError(message, mockTransactionId, mockTxParams, mockTxHex);\n\n      should.exist(error);\n      should.equal(error.message, message);\n      should.equal(error.name, 'TxIntentMismatchError');\n      should.equal(error.id, mockTransactionId);\n      should.deepEqual(error.txParams, mockTxParams);\n      should.equal(error.txHex, mockTxHex);\n      should.equal(error.txExplanation, undefined); // txExplanation is optional\n    });\n\n    it('should create error with txExplanation when provided', () => {\n      const message = 'Transaction does not match user intent';\n      const txExplanationObj = {\n        id: '0xtxid',\n        outputAmount: '1000000',\n        outputs: [{ address: '0xrecipient', amount: '1000000' }],\n        fee: { fee: '21000' },\n      };\n      const error = new TxIntentMismatchError(message, mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);\n\n      should.exist(error);\n      // Should be stringified\n      should.equal(typeof error.txExplanation, 'string');\n      const parsed = JSON.parse(error.txExplanation!);\n      should.equal(parsed.id, '0xtxid');\n      should.equal(parsed.outputAmount, '1000000');\n    });\n\n    it('should be an instance of Error', () => {\n      const error = new TxIntentMismatchError('Test message', mockTransactionId, mockTxParams, mockTxHex);\n\n      should(error).be.instanceOf(Error);\n    });\n  });\n\n  describe('TxIntentMismatchRecipientError', () => {\n    it('should create recipient intent mismatch error with mismatched recipients', () => {\n      const message = 'Transaction recipients do not match user intent';\n      const mismatchedRecipients: MismatchedRecipient[] = [\n        { address: '0xexpected1', amount: '1000' },\n        { address: '0xexpected2', amount: '2000' },\n      ];\n\n      const error = new TxIntentMismatchRecipientError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        mismatchedRecipients\n      );\n\n      should.exist(error);\n      should.equal(error.message, message);\n      should.equal(error.name, 'TxIntentMismatchRecipientError');\n      should.equal(error.id, mockTransactionId);\n      should.deepEqual(error.txParams, mockTxParams);\n      should.equal(error.txHex, mockTxHex);\n      should.deepEqual(error.mismatchedRecipients, mismatchedRecipients);\n      should.equal(error.txExplanation, undefined); // txExplanation is optional\n    });\n\n    it('should create recipient error with txExplanation when provided', () => {\n      const message = 'Transaction recipients do not match user intent';\n      const mismatchedRecipients: MismatchedRecipient[] = [{ address: '0xexpected1', amount: '1000' }];\n      const txExplanationObj = {\n        id: '0xtxid',\n        outputs: [{ address: '0xactual', amount: '1000' }],\n      };\n\n      const error = new TxIntentMismatchRecipientError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        mismatchedRecipients,\n        txExplanationObj\n      );\n\n      should.equal(typeof error.txExplanation, 'string');\n      const parsed = JSON.parse(error.txExplanation!);\n      should.equal(parsed.id, '0xtxid');\n      should.deepEqual(error.mismatchedRecipients, mismatchedRecipients);\n    });\n\n    it('should be an instance of TxIntentMismatchError', () => {\n      const error = new TxIntentMismatchRecipientError('Test message', mockTransactionId, mockTxParams, mockTxHex, []);\n\n      should(error).be.instanceOf(TxIntentMismatchError);\n      should(error).be.instanceOf(Error);\n    });\n  });\n\n  describe('TxIntentMismatchContractError', () => {\n    it('should create contract intent mismatch error with mismatched data payload', () => {\n      const message = 'Contract interaction does not match user intent';\n      const mismatchedDataPayload: ContractDataPayload = {\n        address: '0xcontract123',\n        rawContractPayload: '0xabcdef',\n        decodedContractPayload: { method: 'transfer', params: ['0xrecipient', '1000'] },\n      };\n\n      const error = new TxIntentMismatchContractError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        mismatchedDataPayload\n      );\n\n      should.exist(error);\n      should.equal(error.message, message);\n      should.equal(error.name, 'TxIntentMismatchContractError');\n      should.equal(error.id, mockTransactionId);\n      should.deepEqual(error.txParams, mockTxParams);\n      should.equal(error.txHex, mockTxHex);\n      should.deepEqual(error.mismatchedDataPayload, mismatchedDataPayload);\n      should.equal(error.txExplanation, undefined); // txExplanation is optional\n    });\n\n    it('should create contract error with txExplanation when provided', () => {\n      const message = 'Contract interaction does not match user intent';\n      const mismatchedDataPayload: ContractDataPayload = {\n        address: '0xcontract123',\n        rawContractPayload: '0xabcdef',\n        decodedContractPayload: { method: 'approve', params: ['0xspender', 'unlimited'] },\n      };\n      const txExplanationObj = {\n        id: '0xtxid',\n        outputs: [{ address: '0xcontract123', amount: '0' }],\n        contractCall: { method: 'approve', params: ['0xspender', 'unlimited'] },\n      };\n\n      const error = new TxIntentMismatchContractError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        mismatchedDataPayload,\n        txExplanationObj\n      );\n\n      should.equal(typeof error.txExplanation, 'string');\n      const parsed = JSON.parse(error.txExplanation!);\n      should.equal(parsed.id, '0xtxid');\n      should.deepEqual(error.mismatchedDataPayload, mismatchedDataPayload);\n    });\n\n    it('should be an instance of TxIntentMismatchError', () => {\n      const error = new TxIntentMismatchContractError('Test message', mockTransactionId, mockTxParams, mockTxHex, {\n        address: '0xtest',\n        rawContractPayload: '0x',\n        decodedContractPayload: {},\n      });\n\n      should(error).be.instanceOf(TxIntentMismatchError);\n      should(error).be.instanceOf(Error);\n    });\n  });\n\n  describe('TxIntentMismatchApprovalError', () => {\n    it('should create approval intent mismatch error with token approval details', () => {\n      const message = 'Token approval does not match user intent';\n      const tokenApproval: TokenApproval = {\n        tokenName: 'TestToken',\n        tokenAddress: '0xtoken123',\n        authorizingAmount: { type: 'unlimited' },\n        authorizingAddress: '0xspender456',\n      };\n\n      const error = new TxIntentMismatchApprovalError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        tokenApproval\n      );\n\n      should.exist(error);\n      should.equal(error.message, message);\n      should.equal(error.name, 'TxIntentMismatchApprovalError');\n      should.equal(error.id, mockTransactionId);\n      should.deepEqual(error.txParams, mockTxParams);\n      should.equal(error.txHex, mockTxHex);\n      should.deepEqual(error.tokenApproval, tokenApproval);\n      should.equal(error.txExplanation, undefined); // txExplanation is optional\n    });\n\n    it('should create approval error with txExplanation when provided', () => {\n      const message = 'Token approval does not match user intent';\n      const tokenApproval: TokenApproval = {\n        tokenName: 'USDC',\n        tokenAddress: '0xusdc',\n        authorizingAmount: { type: 'unlimited' },\n        authorizingAddress: '0xmalicious',\n      };\n      const txExplanationObj = {\n        id: '0xtxid',\n        outputs: [{ address: '0xusdc', amount: '0' }],\n        tokenApproval: {\n          token: 'USDC',\n          spender: '0xmalicious',\n          amount: 'unlimited',\n        },\n      };\n\n      const error = new TxIntentMismatchApprovalError(\n        message,\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        tokenApproval,\n        txExplanationObj\n      );\n\n      should.equal(typeof error.txExplanation, 'string');\n      const parsed = JSON.parse(error.txExplanation!);\n      should.equal(parsed.id, '0xtxid');\n      should.deepEqual(error.tokenApproval, tokenApproval);\n    });\n\n    it('should be an instance of TxIntentMismatchError', () => {\n      const error = new TxIntentMismatchApprovalError('Test message', mockTransactionId, mockTxParams, mockTxHex, {\n        tokenAddress: '0xtoken',\n        authorizingAmount: { type: 'limited', amount: 1000 },\n        authorizingAddress: '0xspender',\n      });\n\n      should(error).be.instanceOf(TxIntentMismatchError);\n      should(error).be.instanceOf(Error);\n    });\n  });\n\n  describe('Error inheritance and properties', () => {\n    it('should maintain proper inheritance chain', () => {\n      const baseError = new TxIntentMismatchError('Base error', mockTransactionId, mockTxParams, mockTxHex);\n      const recipientError = new TxIntentMismatchRecipientError(\n        'Recipient error',\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        []\n      );\n      const contractError = new TxIntentMismatchContractError(\n        'Contract error',\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        { address: '0xtest', rawContractPayload: '0x', decodedContractPayload: {} }\n      );\n      const approvalError = new TxIntentMismatchApprovalError(\n        'Approval error',\n        mockTransactionId,\n        mockTxParams,\n        mockTxHex,\n        {\n          tokenAddress: '0xtoken',\n          authorizingAmount: { type: 'limited', amount: 1000 },\n          authorizingAddress: '0xspender',\n        }\n      );\n\n      // All should be instances of Error\n      should(baseError).be.instanceOf(Error);\n      should(recipientError).be.instanceOf(Error);\n      should(contractError).be.instanceOf(Error);\n      should(approvalError).be.instanceOf(Error);\n\n      // All should be instances of TxIntentMismatchError\n      should(recipientError).be.instanceOf(TxIntentMismatchError);\n      should(contractError).be.instanceOf(TxIntentMismatchError);\n      should(approvalError).be.instanceOf(TxIntentMismatchError);\n    });\n\n    it('should preserve stack trace', () => {\n      const error = new TxIntentMismatchError('Test error', mockTransactionId, mockTxParams, mockTxHex);\n\n      should.exist(error.stack);\n      should(error.stack).be.a.String();\n      should(error.stack).containEql('TxIntentMismatchError');\n    });\n  });\n\n  describe('Transaction explanation property', () => {\n    it('should handle valid JSON transaction explanations', () => {\n      const txExplanationObj = {\n        id: '0x123abc',\n        outputAmount: '1000000000000000000',\n        outputs: [\n          { address: '0xrecipient1', amount: '500000000000000000' },\n          { address: '0xrecipient2', amount: '500000000000000000' },\n        ],\n        fee: { fee: '21000', gasLimit: '21000' },\n        type: 'send',\n      };\n\n      const error = new TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);\n\n      should.equal(typeof error.txExplanation, 'string');\n      // Verify it can be parsed back\n      const parsed = JSON.parse(error.txExplanation!);\n      should.equal(parsed.id, '0x123abc');\n      should.equal(parsed.outputs.length, 2);\n    });\n\n    it('should handle empty transaction explanation', () => {\n      const error = new TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, undefined);\n\n      should.equal(error.txExplanation, undefined);\n    });\n\n    it('should handle BigInt values in transaction explanation', () => {\n      const txExplanationObj = {\n        id: '0x123',\n        outputAmount: BigInt('9007199254740992'),\n        changeAmount: BigInt('1234567890123456789'),\n        outputs: [{ address: 'addr1', amount: BigInt('9007199254740992') }],\n      };\n\n      const error = new TxIntentMismatchError('Test', mockTransactionId, mockTxParams, mockTxHex, txExplanationObj);\n\n      should.equal(typeof error.txExplanation, 'string');\n      const parsed = JSON.parse(error.txExplanation!);\n      // BigInts should be converted to strings\n      should.equal(parsed.outputAmount, '9007199254740992');\n      should.equal(parsed.changeAmount, '1234567890123456789');\n      should.equal(parsed.outputs[0].amount, '9007199254740992');\n    });\n\n    it('should work with all error subclasses', () => {\n      const txExplanationObj = { id: '0x123', outputs: [] };\n\n      const errors = [\n        new TxIntentMismatchRecipientError('Test', mockTransactionId, mockTxParams, mockTxHex, [], txExplanationObj),\n        new TxIntentMismatchContractError(\n          'Test',\n          mockTransactionId,\n          mockTxParams,\n          mockTxHex,\n          { address: '0x', rawContractPayload: '0x', decodedContractPayload: {} },\n          txExplanationObj\n        ),\n        new TxIntentMismatchApprovalError(\n          'Test',\n          mockTransactionId,\n          mockTxParams,\n          mockTxHex,\n          { tokenAddress: '0x', authorizingAmount: { type: 'limited', amount: 0 }, authorizingAddress: '0x' },\n          txExplanationObj\n        ),\n      ];\n\n      errors.forEach((error) => {\n        should.equal(typeof error.txExplanation, 'string');\n        const parsed = JSON.parse(error.txExplanation!);\n        should.equal(parsed.id, '0x123');\n      });\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/trading/network/encrypt.d.ts

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

package/dist/test/unit/bitgo/trading/network/encrypt.d.ts.map

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

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

@@ -0,0 +1,71 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = __importDefault(require("assert"));
+const crypto_1 = __importDefault(require("crypto"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const decrypt_rsa_1 = require("../../../../../src/bitgo/trading/network/decrypt-rsa");
+const encrypt_rsa_1 = require("../../../../../src/bitgo/trading/network/encrypt-rsa");
+const encrypt_rsa_browser_1 = require("../../../../../src/bitgo/trading/network/encrypt-rsa-browser");
+const decrypt_aes_gcm_1 = require("../../../../../src/bitgo/trading/network/decrypt-aes-gcm");
+const encrypt_aes_gcm_1 = require("../../../../../src/bitgo/trading/network/encrypt-aes-gcm");
+const network_1 = require("../../../../../src/bitgo/trading/network");
+describe('network encrypt', () => {
+    const privateKey = fs_1.default.readFileSync(path_1.default.resolve(__dirname, './private-key.pem'));
+    const publicKey = fs_1.default.readFileSync(path_1.default.resolve(__dirname, './public-key.pub'));
+    const password = 'password';
+    let encryptedRsa;
+    let decryptedRsa;
+    let encryptedBrowserRsa;
+    it('should encrypt the string with a rsa public key', async () => {
+        encryptedRsa = await (0, encrypt_rsa_1._encryptRsa)(publicKey.toString(), password);
+        (0, assert_1.default)(encryptedRsa);
+    });
+    it('should decrypt the string with a rsa public key', async () => {
+        decryptedRsa = await (0, decrypt_rsa_1._decryptRsa)(privateKey.toString(), encryptedRsa);
+        (0, assert_1.default)(decryptedRsa);
+        assert_1.default.strictEqual(decryptedRsa, password);
+    });
+    it('should encrypt the string with a rsa public key for the browser', async () => {
+        encryptedBrowserRsa = await (0, encrypt_rsa_browser_1._encryptBrowserRsa)(publicKey.toString(), password);
+        (0, assert_1.default)(encryptedBrowserRsa);
+    });
+    it('should encrypt and decrypt aes-gcm', async () => {
+        // Use encryptAesGcm and decryptAesGcm
+        const text = 'secret';
+        const gcmKey = crypto_1.default.randomBytes(32).toString('base64');
+        const encrypted = await (0, encrypt_aes_gcm_1._encryptAesGcm)(gcmKey, text);
+        const decrypted = await (0, decrypt_aes_gcm_1._decryptAesGcm)(gcmKey, encrypted);
+        assert_1.default.strictEqual(decrypted, text);
+    });
+    let encryptedRsaWithAesGcm;
+    let decryptedRsaWithAesGcm;
+    let encryptedBrowserRsaWithAesGcm;
+    let decryptedBrowserRsaWithAesGcm;
+    it('should encrypt and decrypt RsaWithAesGcm', async () => {
+        encryptedRsaWithAesGcm = await (0, network_1.encryptRsaWithAesGcm)(publicKey.toString(), password);
+        decryptedRsaWithAesGcm = await (0, network_1.decryptRsaWithAesGcm)(privateKey.toString(), encryptedRsaWithAesGcm);
+        (0, assert_1.default)(encryptedRsaWithAesGcm);
+        (0, assert_1.default)(decryptedRsaWithAesGcm);
+    });
+    it('should encrypt and decrypt RsaWithAesGcm for the browser', async () => {
+        encryptedBrowserRsaWithAesGcm = await (0, network_1.encryptBrowserRsaWithAesGcm)(publicKey.toString(), password);
+        decryptedBrowserRsaWithAesGcm = await (0, network_1.decryptRsaWithAesGcm)(privateKey.toString(), encryptedBrowserRsaWithAesGcm);
+        assert_1.default.strictEqual(decryptedBrowserRsaWithAesGcm, password);
+        assert_1.default.strictEqual(decryptedRsaWithAesGcm, decryptedBrowserRsaWithAesGcm);
+    });
+    it('should check that the encryptions for node and browser work with each other', async () => {
+        // We only care about browser and node encryption working with node decryption
+        // We will never decrypt in the browser
+        const browserEncrypted = await (0, encrypt_rsa_browser_1._encryptBrowserRsa)(publicKey.toString(), password);
+        const nodeDecrypted = await (0, decrypt_rsa_1._decryptRsa)(privateKey.toString(), browserEncrypted);
+        assert_1.default.strictEqual(nodeDecrypted, password);
+        const browserEncryptedWithAesGcm = await (0, network_1.encryptBrowserRsaWithAesGcm)(publicKey.toString(), password);
+        const nodeDecryptedWithAesGcm = await (0, network_1.decryptRsaWithAesGcm)(privateKey.toString(), browserEncryptedWithAesGcm);
+        assert_1.default.strictEqual(nodeDecryptedWithAesGcm, password);
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"encrypt.js","sourceRoot":"","sources":["../../../../../../test/unit/bitgo/trading/network/encrypt.ts"],"names":[],"mappings":"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","sourcesContent":["import assert from 'assert';\nimport crypto from 'crypto';\nimport fs from 'fs';\nimport path from 'path';\nimport { _decryptRsa } from '../../../../../src/bitgo/trading/network/decrypt-rsa';\nimport { _encryptRsa } from '../../../../../src/bitgo/trading/network/encrypt-rsa';\nimport { _encryptBrowserRsa } from '../../../../../src/bitgo/trading/network/encrypt-rsa-browser';\nimport { _decryptAesGcm } from '../../../../../src/bitgo/trading/network/decrypt-aes-gcm';\nimport { _encryptAesGcm } from '../../../../../src/bitgo/trading/network/encrypt-aes-gcm';\nimport {\n  decryptRsaWithAesGcm,\n  encryptBrowserRsaWithAesGcm,\n  encryptRsaWithAesGcm,\n} from '../../../../../src/bitgo/trading/network';\n\ndescribe('network encrypt', () => {\n  const privateKey = fs.readFileSync(path.resolve(__dirname, './private-key.pem'));\n  const publicKey = fs.readFileSync(path.resolve(__dirname, './public-key.pub'));\n\n  const password = 'password';\n\n  let encryptedRsa;\n  let decryptedRsa;\n  let encryptedBrowserRsa;\n\n  it('should encrypt the string with a rsa public key', async () => {\n    encryptedRsa = await _encryptRsa(publicKey.toString(), password);\n    assert(encryptedRsa);\n  });\n\n  it('should decrypt the string with a rsa public key', async () => {\n    decryptedRsa = await _decryptRsa(privateKey.toString(), encryptedRsa);\n    assert(decryptedRsa);\n    assert.strictEqual(decryptedRsa, password);\n  });\n\n  it('should encrypt the string with a rsa public key for the browser', async () => {\n    encryptedBrowserRsa = await _encryptBrowserRsa(publicKey.toString(), password);\n    assert(encryptedBrowserRsa);\n  });\n\n  it('should encrypt and decrypt aes-gcm', async () => {\n    // Use encryptAesGcm and decryptAesGcm\n    const text = 'secret';\n    const gcmKey = crypto.randomBytes(32).toString('base64');\n    const encrypted = await _encryptAesGcm(gcmKey, text);\n    const decrypted = await _decryptAesGcm(gcmKey, encrypted);\n    assert.strictEqual(decrypted, text);\n  });\n\n  let encryptedRsaWithAesGcm;\n  let decryptedRsaWithAesGcm;\n  let encryptedBrowserRsaWithAesGcm;\n  let decryptedBrowserRsaWithAesGcm;\n\n  it('should encrypt and decrypt RsaWithAesGcm', async () => {\n    encryptedRsaWithAesGcm = await encryptRsaWithAesGcm(publicKey.toString(), password);\n    decryptedRsaWithAesGcm = await decryptRsaWithAesGcm(privateKey.toString(), encryptedRsaWithAesGcm);\n    assert(encryptedRsaWithAesGcm);\n    assert(decryptedRsaWithAesGcm);\n  });\n\n  it('should encrypt and decrypt RsaWithAesGcm for the browser', async () => {\n    encryptedBrowserRsaWithAesGcm = await encryptBrowserRsaWithAesGcm(publicKey.toString(), password);\n    decryptedBrowserRsaWithAesGcm = await decryptRsaWithAesGcm(privateKey.toString(), encryptedBrowserRsaWithAesGcm);\n\n    assert.strictEqual(decryptedBrowserRsaWithAesGcm, password);\n    assert.strictEqual(decryptedRsaWithAesGcm, decryptedBrowserRsaWithAesGcm);\n  });\n\n  it('should check that the encryptions for node and browser work with each other', async () => {\n    // We only care about browser and node encryption working with node decryption\n    // We will never decrypt in the browser\n\n    const browserEncrypted = await _encryptBrowserRsa(publicKey.toString(), password);\n    const nodeDecrypted = await _decryptRsa(privateKey.toString(), browserEncrypted);\n    assert.strictEqual(nodeDecrypted, password);\n\n    const browserEncryptedWithAesGcm = await encryptBrowserRsaWithAesGcm(publicKey.toString(), password);\n    const nodeDecryptedWithAesGcm = await decryptRsaWithAesGcm(privateKey.toString(), browserEncryptedWithAesGcm);\n    assert.strictEqual(nodeDecryptedWithAesGcm, password);\n  });\n});\n"]}

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

@@ -8,7 +8,7 @@ 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']));
@@ -16,10 +16,30 @@ describe('getUtxoCoinScriptTypes', function () {
         assert_1.default.ok(fn('doge', ['p2sh']));
     });
     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.getUtxoCoinScriptTypes2Of3)('dummy'), (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.getUtxoCoinScriptTypes2Of3)('eth'), (e) => e.message === 'coin eth is not a utxo coin');
     });
 });
-//# sourceMappingURL=data:application/json;base64,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
+describe('getUtxoCoinScriptTypesForWalletType', function () {
+    it('success', function () {
+        const fn = (coin, walletType, arr) => {
+            const scriptTypes = (0, src_1.getUtxoCoinScriptTypes2Of3)(coin);
+            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('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');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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":""}

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

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const should_1 = __importDefault(require("should"));
+const src_1 = require("../../../../src");
+describe('Message Types', () => {
+    describe('MessageStandardType', () => {
+        it('should define supported message standard types', () => {
+            should_1.default.exist(src_1.MessageStandardType.UNKNOWN);
+            should_1.default.exist(src_1.MessageStandardType.EIP191);
+            should_1.default.equal(src_1.MessageStandardType.UNKNOWN, 'UNKNOWN');
+            should_1.default.equal(src_1.MessageStandardType.EIP191, 'EIP191');
+        });
+    });
+    describe('BroadcastableMessage', () => {
+        it('should validate interface structure', () => {
+            const message = {
+                type: src_1.MessageStandardType.EIP191,
+                payload: 'Test payload',
+                serializedSignatures: [
+                    {
+                        publicKey: 'pub1',
+                        signature: 'signature1',
+                    },
+                    {
+                        publicKey: 'pub2',
+                        signature: 'signature2',
+                    },
+                ],
+                signers: ['signer1', 'signer2'],
+                metadata: { chainId: 1 },
+                signablePayload: 'signable payload',
+            };
+            should_1.default.equal(message.type, src_1.MessageStandardType.EIP191);
+            should_1.default.equal(message.payload, 'Test payload');
+            should_1.default.deepEqual(message.serializedSignatures, [
+                {
+                    publicKey: 'pub1',
+                    signature: 'signature1',
+                },
+                {
+                    publicKey: 'pub2',
+                    signature: 'signature2',
+                },
+            ]);
+            should_1.default.deepEqual(message.signers, ['signer1', 'signer2']);
+            should_1.default.deepEqual(message.metadata, { chainId: 1 });
+            should_1.default.deepEqual(message.signablePayload, 'signable payload');
+        });
+        it('should allow optional fields to be undefined', () => {
+            const message = {
+                type: src_1.MessageStandardType.UNKNOWN,
+                payload: 'Minimal message',
+                serializedSignatures: [],
+                signers: [],
+            };
+            should_1.default.not.exist(message.metadata);
+            should_1.default.not.exist(message.signablePayload);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+require("should");
+const src_1 = require("../../../../src");
+describe('notEmpty', () => {
+    const notEmptyValues = [1, '123', { something: true }, {}];
+    const emptyValues = [undefined, null];
+    it('should return true', () => {
+        notEmptyValues.forEach((vaue) => (0, src_1.notEmpty)(vaue).should.equal(true));
+    });
+    it('should return false', () => {
+        emptyValues.forEach((vaue) => (0, src_1.notEmpty)(vaue).should.equal(false));
+    });
+});
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibm90RW1wdHkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi90ZXN0L3VuaXQvYml0Z28vdXRpbHMvbm90RW1wdHkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7QUFBQSxrQkFBZ0I7QUFDaEIseUNBQTJDO0FBQzNDLFFBQVEsQ0FBQyxVQUFVLEVBQUUsR0FBRyxFQUFFO0lBQ3hCLE1BQU0sY0FBYyxHQUFHLENBQUMsQ0FBQyxFQUFFLEtBQUssRUFBRSxFQUFFLFNBQVMsRUFBRSxJQUFJLEVBQUUsRUFBRSxFQUFFLENBQUMsQ0FBQztJQUMzRCxNQUFNLFdBQVcsR0FBRyxDQUFDLFNBQVMsRUFBRSxJQUFJLENBQUMsQ0FBQztJQUV0QyxFQUFFLENBQUMsb0JBQW9CLEVBQUUsR0FBRyxFQUFFO1FBQzVCLGNBQWMsQ0FBQyxPQUFPLENBQUMsQ0FBQyxJQUFJLEVBQUUsRUFBRSxDQUFDLElBQUEsY0FBUSxFQUFDLElBQUksQ0FBQyxDQUFDLE1BQU0sQ0FBQyxLQUFLLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQztJQUN0RSxDQUFDLENBQUMsQ0FBQztJQUVILEVBQUUsQ0FBQyxxQkFBcUIsRUFBRSxHQUFHLEVBQUU7UUFDN0IsV0FBVyxDQUFDLE9BQU8sQ0FBQyxDQUFDLElBQUksRUFBRSxFQUFFLENBQUMsSUFBQSxjQUFRLEVBQUMsSUFBSSxDQUFDLENBQUMsTUFBTSxDQUFDLEtBQUssQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDO0lBQ3BFLENBQUMsQ0FBQyxDQUFDO0FBQ0wsQ0FBQyxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgJ3Nob3VsZCc7XG5pbXBvcnQgeyBub3RFbXB0eSB9IGZyb20gJy4uLy4uLy4uLy4uL3NyYyc7XG5kZXNjcmliZSgnbm90RW1wdHknLCAoKSA9PiB7XG4gIGNvbnN0IG5vdEVtcHR5VmFsdWVzID0gWzEsICcxMjMnLCB7IHNvbWV0aGluZzogdHJ1ZSB9LCB7fV07XG4gIGNvbnN0IGVtcHR5VmFsdWVzID0gW3VuZGVmaW5lZCwgbnVsbF07XG5cbiAgaXQoJ3Nob3VsZCByZXR1cm4gdHJ1ZScsICgpID0+IHtcbiAgICBub3RFbXB0eVZhbHVlcy5mb3JFYWNoKCh2YXVlKSA9PiBub3RFbXB0eSh2YXVlKS5zaG91bGQuZXF1YWwodHJ1ZSkpO1xuICB9KTtcblxuICBpdCgnc2hvdWxkIHJldHVybiBmYWxzZScsICgpID0+IHtcbiAgICBlbXB0eVZhbHVlcy5mb3JFYWNoKCh2YXVlKSA9PiBub3RFbXB0eSh2YXVlKS5zaG91bGQuZXF1YWwoZmFsc2UpKTtcbiAgfSk7XG59KTtcbiJdfQ==