@bitgo-beta/sdk-core 8.2.1-beta.214 → 8.2.1-beta.2140

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

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

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

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

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

@@ -0,0 +1,38 @@
+"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('zkSync Era Environment Configuration', function () {
+    it('should have evm config for mainnet zksyncera', function () {
+        const mainnetEnv = src_1.Environments.prod;
+        should_1.default.exist(mainnetEnv.evm);
+        should_1.default.exist(mainnetEnv.evm?.zksyncera);
+        mainnetEnv.evm?.zksyncera.baseUrl.should.equal('https://api.etherscan.io/v2');
+    });
+    it('should have evm config for testnet zksyncera', function () {
+        const testnetEnv = src_1.Environments.test;
+        should_1.default.exist(testnetEnv.evm);
+        should_1.default.exist(testnetEnv.evm?.zksyncera);
+        testnetEnv.evm?.zksyncera.baseUrl.should.equal('https://api.etherscan.io/v2');
+    });
+});
+describe('HypeEvm Bridging Environment Configuration', function () {
+    it('should have bridging config for mainnet Hypeevm', function () {
+        const mainnetEnv = src_1.Environments.prod;
+        should_1.default.exist(mainnetEnv.evm);
+        should_1.default.exist(mainnetEnv.evm?.hypeevm);
+        mainnetEnv.evm?.hypeevm.tokenId?.should.equal(150);
+        mainnetEnv.evm?.hypeevm.systemAddr?.should.equal('0x2222222222222222222222222222222222222222');
+    });
+    it('should have bridging config for testnet Hypeevm', function () {
+        const testnetEnv = src_1.Environments.test;
+        should_1.default.exist(testnetEnv.evm);
+        should_1.default.exist(testnetEnv.evm?.hypeevm);
+        testnetEnv.evm?.hypeevm.tokenId?.should.equal(1105);
+        testnetEnv.evm?.hypeevm.systemAddr?.should.equal('0x2222222222222222222222222222222222222222');
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

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

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

@@ -0,0 +1,276 @@
+"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');
+            });
+        });
+    });
+});
+describe('RecoveryKeyMismatchError', () => {
+    it('should set name, code, and default message', () => {
+        const error = new errors_1.RecoveryKeyMismatchError();
+        error.name.should.equal('RecoveryKeyMismatchError');
+        error.code.should.equal('recovery_key_mismatch');
+        error.message.should.equal('recovery keys do not match the wallet on-chain signer set');
+        (0, should_1.default)(error).be.an.instanceof(errors_1.BitGoJsError);
+    });
+    it('should respect a custom message', () => {
+        const error = new errors_1.RecoveryKeyMismatchError('custom mismatch message');
+        error.message.should.equal('custom mismatch message');
+        error.code.should.equal('recovery_key_mismatch');
+    });
+});
+//# 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  RecoveryKeyMismatchError,\n  BitGoJsError,\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\ndescribe('RecoveryKeyMismatchError', () => {\n  it('should set name, code, and default message', () => {\n    const error = new RecoveryKeyMismatchError();\n    error.name.should.equal('RecoveryKeyMismatchError');\n    error.code.should.equal('recovery_key_mismatch');\n    error.message.should.equal('recovery keys do not match the wallet on-chain signer set');\n    should(error).be.an.instanceof(BitGoJsError);\n  });\n\n  it('should respect a custom message', () => {\n    const error = new RecoveryKeyMismatchError('custom mismatch message');\n    error.message.should.equal('custom mismatch message');\n    error.code.should.equal('recovery_key_mismatch');\n  });\n});\n"]}

package/dist/test/unit/bitgo/keychain/keychains.d.ts

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

package/dist/test/unit/bitgo/keychain/keychains.d.ts.map

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