@bitgo-beta/sdk-core 8.2.1-beta.207 → 8.2.1-beta.2070

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,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/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"}

package/dist/test/unit/bitgo/keychain/keychains.js

@@ -0,0 +1,166 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon = __importStar(require("sinon"));
+require("should");
+const src_1 = require("../../../../src");
+/** Slot-④ roots are generated as XLM keychains, then persisted as raw pub||chain-code base32. */
+const STRKEY_PUB = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';
+const SAFE_ID = 'safe-1';
+const XPUB = 'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';
+const BASE32_ROOT = /^[A-Z2-7]{103}$/;
+describe('Keychains.createBackup', function () {
+    let keychains;
+    let send;
+    let mockBitGo;
+    /** The body actually handed to `.send()` — i.e. what goes on the wire. */
+    function sentBody() {
+        return send.firstCall.args[0];
+    }
+    function buildKeychains(pub = STRKEY_PUB) {
+        const mockBaseCoin = {
+            url: sinon.stub().callsFake((path) => path),
+            generateKeyPair: sinon.stub().returns({ pub, prv: 'SOME_SEED' }),
+        };
+        return new src_1.Keychains(mockBitGo, mockBaseCoin);
+    }
+    beforeEach(function () {
+        send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'backup-key-id' }) });
+        mockBitGo = {
+            post: sinon.stub().returns({ send }),
+            encrypt: sinon.stub().resolves('encrypted-prv'),
+            setRequestTracer: sinon.stub(),
+        };
+        keychains = buildKeychains();
+    });
+    describe('safe child key registration', function () {
+        it('serializes the hardened derivation path', async function () {
+            await keychains.add({
+                pub: XPUB,
+                source: 'user',
+                keyType: 'independent',
+                parent: 'user-root-id',
+                safeId: SAFE_ID,
+                derivedFromParentWithPath: "m/7'",
+            });
+            const derivedPath = sentBody().derivedFromParentWithPath;
+            if (typeof derivedPath !== 'string') {
+                throw new Error('expected derivedFromParentWithPath to be serialized');
+            }
+            derivedPath.should.equal("m/7'");
+        });
+    });
+    describe('safe ed25519Multisig root (slot ④)', function () {
+        it('posts raw public key plus chain code as unpadded base32', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const pub = sentBody().pub;
+            BASE32_ROOT.test(pub).should.equal(true);
+            (0, src_1.decodeDerivableEd25519Pub)(pub)
+                .pub.toString('hex')
+                .should.match(/^[0-9a-f]{64}$/);
+            (0, src_1.decodeDerivableEd25519Pub)(pub)
+                .chainCode.toString('hex')
+                .should.match(/^[0-9a-f]{64}$/);
+        });
+        it('mints a different chain code for each backup key', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const first = (0, src_1.decodeDerivableEd25519Pub)(send.firstCall.args[0].pub).chainCode;
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            const second = (0, src_1.decodeDerivableEd25519Pub)(send.secondCall.args[0].pub).chainCode;
+            first.equals(second).should.equal(false);
+        });
+        it('sends no separate chainCode field', async function () {
+            await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().should.not.have.property('chainCode');
+        });
+        it('still encrypts and returns the un-composed prv', async function () {
+            const result = await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().encryptedPrv.should.equal('encrypted-prv');
+            result.prv.should.equal('SOME_SEED');
+        });
+    });
+    describe('leaves every other key untouched', function () {
+        it('does not compose without a safeId, even for an ed25519 coin', async function () {
+            await keychains.createBackup({ passphrase: 'pw' });
+            const body = sentBody();
+            body.pub.should.equal(STRKEY_PUB);
+            body.pub.length.should.equal(56);
+        });
+        it('does not compose a safe secp256k1Multisig root', async function () {
+            const btcKeychains = buildKeychains(XPUB);
+            await btcKeychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });
+            sentBody().pub.should.equal(XPUB);
+        });
+        it('sends a body with no chainCode and source backup', async function () {
+            await keychains.createBackup({ passphrase: 'pw' });
+            const body = sentBody();
+            body.should.not.have.property('chainCode');
+            body.source.should.equal('backup');
+            body.encryptedPrv.should.equal('encrypted-prv');
+        });
+        it('leaves a KRS-provider backup key untouched', async function () {
+            await keychains.createBackup({ provider: 'krs-provider', safeId: SAFE_ID });
+            const body = sentBody();
+            (body.pub === undefined).should.be.true();
+            body.provider.should.equal('krs-provider');
+        });
+    });
+    describe('password rotation encryption session', function () {
+        it('uses the supplied session for the new encrypted private key', async function () {
+            mockBitGo.decrypt = sinon.stub().resolves('decrypted-prv');
+            const sessionEncrypt = sinon.stub().resolves('session-encrypted');
+            const session = {
+                encrypt: sessionEncrypt,
+                decrypt: sinon.stub().resolves('decrypted-prv'),
+                destroy: sinon.stub(),
+            };
+            const updatedKeychain = await keychains.updateSingleKeychainPassword({
+                keychain: {
+                    id: 'key-id',
+                    encryptedPrv: 'legacy-encrypted-prv',
+                    type: 'independent',
+                },
+                oldPassword: 'old-password',
+                newPassword: 'new-password',
+                encryptionVersion: 2,
+                encryptionSession: session,
+            });
+            sessionEncrypt.calledOnceWithExactly('decrypted-prv').should.equal(true);
+            mockBitGo.encrypt.called.should.equal(false);
+            updatedKeychain.encryptedPrv.should.equal('session-encrypted');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keychains.js","sourceRoot":"","sources":["../../../../../test/unit/bitgo/keychain/keychains.ts"],"names":[],"mappings":"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","sourcesContent":["import * as sinon from 'sinon';\nimport 'should';\nimport { Keychains, decodeDerivableEd25519Pub } from '../../../../src';\nimport type { IEncryptionSession } from '../../../../src/api';\n\n/** Slot-④ roots are generated as XLM keychains, then persisted as raw pub||chain-code base32. */\nconst STRKEY_PUB = 'GA5WUJ54Z23KILLCUOUNAKTPBVZWKMQVO4O6EQ5GHLAERIMLLHNCSKYH';\nconst SAFE_ID = 'safe-1';\nconst XPUB =\n  'xpub661MyMwAqRbcFtXgS5sYJABqqG9YLmC4Q1Rdap9gSE8NqtwybGhePY2gZ29ESFjqJoCu1Rupje8YtGqsefD265TMg7usUDFdp6W1EGMcet8';\nconst BASE32_ROOT = /^[A-Z2-7]{103}$/;\n\ndescribe('Keychains.createBackup', function () {\n  let keychains: Keychains;\n  let send: sinon.SinonStub;\n  let mockBitGo: any;\n\n  /** The body actually handed to `.send()` — i.e. what goes on the wire. */\n  function sentBody(): Record<string, unknown> {\n    return send.firstCall.args[0];\n  }\n\n  function buildKeychains(pub = STRKEY_PUB): Keychains {\n    const mockBaseCoin = {\n      url: sinon.stub().callsFake((path: string) => path),\n      generateKeyPair: sinon.stub().returns({ pub, prv: 'SOME_SEED' }),\n    };\n    return new Keychains(mockBitGo, mockBaseCoin as any);\n  }\n\n  beforeEach(function () {\n    send = sinon.stub().returns({ result: sinon.stub().resolves({ id: 'backup-key-id' }) });\n    mockBitGo = {\n      post: sinon.stub().returns({ send }),\n      encrypt: sinon.stub().resolves('encrypted-prv'),\n      setRequestTracer: sinon.stub(),\n    };\n    keychains = buildKeychains();\n  });\n\n  describe('safe child key registration', function () {\n    it('serializes the hardened derivation path', async function () {\n      await keychains.add({\n        pub: XPUB,\n        source: 'user',\n        keyType: 'independent',\n        parent: 'user-root-id',\n        safeId: SAFE_ID,\n        derivedFromParentWithPath: \"m/7'\",\n      });\n\n      const derivedPath = sentBody().derivedFromParentWithPath;\n      if (typeof derivedPath !== 'string') {\n        throw new Error('expected derivedFromParentWithPath to be serialized');\n      }\n      derivedPath.should.equal(\"m/7'\");\n    });\n  });\n\n  describe('safe ed25519Multisig root (slot ④)', function () {\n    it('posts raw public key plus chain code as unpadded base32', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n\n      const pub = sentBody().pub as string;\n      BASE32_ROOT.test(pub).should.equal(true);\n      decodeDerivableEd25519Pub(pub)\n        .pub.toString('hex')\n        .should.match(/^[0-9a-f]{64}$/);\n      decodeDerivableEd25519Pub(pub)\n        .chainCode.toString('hex')\n        .should.match(/^[0-9a-f]{64}$/);\n    });\n\n    it('mints a different chain code for each backup key', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      const first = decodeDerivableEd25519Pub(send.firstCall.args[0].pub).chainCode;\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      const second = decodeDerivableEd25519Pub(send.secondCall.args[0].pub).chainCode;\n      first.equals(second).should.equal(false);\n    });\n\n    it('sends no separate chainCode field', async function () {\n      await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().should.not.have.property('chainCode');\n    });\n\n    it('still encrypts and returns the un-composed prv', async function () {\n      const result = await keychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().encryptedPrv!.should.equal('encrypted-prv');\n      result.prv!.should.equal('SOME_SEED');\n    });\n  });\n\n  describe('leaves every other key untouched', function () {\n    it('does not compose without a safeId, even for an ed25519 coin', async function () {\n      await keychains.createBackup({ passphrase: 'pw' });\n      const body = sentBody();\n      body.pub!.should.equal(STRKEY_PUB);\n      (body.pub as string).length.should.equal(56);\n    });\n\n    it('does not compose a safe secp256k1Multisig root', async function () {\n      const btcKeychains = buildKeychains(XPUB);\n      await btcKeychains.createBackup({ passphrase: 'pw', safeId: SAFE_ID });\n      sentBody().pub!.should.equal(XPUB);\n    });\n\n    it('sends a body with no chainCode and source backup', async function () {\n      await keychains.createBackup({ passphrase: 'pw' });\n\n      const body = sentBody();\n      body.should.not.have.property('chainCode');\n      body.source!.should.equal('backup');\n      body.encryptedPrv!.should.equal('encrypted-prv');\n    });\n\n    it('leaves a KRS-provider backup key untouched', async function () {\n      await keychains.createBackup({ provider: 'krs-provider', safeId: SAFE_ID });\n\n      const body = sentBody();\n      (body.pub === undefined).should.be.true();\n      body.provider!.should.equal('krs-provider');\n    });\n  });\n  describe('password rotation encryption session', function () {\n    it('uses the supplied session for the new encrypted private key', async function () {\n      mockBitGo.decrypt = sinon.stub().resolves('decrypted-prv');\n      const sessionEncrypt = sinon.stub().resolves('session-encrypted');\n      const session: IEncryptionSession = {\n        encrypt: sessionEncrypt,\n        decrypt: sinon.stub().resolves('decrypted-prv'),\n        destroy: sinon.stub(),\n      };\n\n      const updatedKeychain = await keychains.updateSingleKeychainPassword({\n        keychain: {\n          id: 'key-id',\n          encryptedPrv: 'legacy-encrypted-prv',\n          type: 'independent',\n        },\n        oldPassword: 'old-password',\n        newPassword: 'new-password',\n        encryptionVersion: 2,\n        encryptionSession: session,\n      });\n\n      sessionEncrypt.calledOnceWithExactly('decrypted-prv').should.equal(true);\n      mockBitGo.encrypt.called.should.equal(false);\n      updatedKeychain.encryptedPrv!.should.equal('session-encrypted');\n    });\n  });\n});\n"]}

package/dist/test/unit/bitgo/recovery/initiate.d.ts

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

package/dist/test/unit/bitgo/recovery/initiate.d.ts.map

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