@bitgo/sdk-coin-tempo 1.12.4 → 1.13.0

package/dist/test/unit/tempo.js

@@ -0,0 +1,207 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sinon_1 = __importDefault(require("sinon"));
+const should_1 = __importDefault(require("should"));
+const sdk_api_1 = require("@bitgo/sdk-api");
+const sdk_test_1 = require("@bitgo/sdk-test");
+const statics_1 = require("@bitgo/statics");
+const tempo_1 = require("../../src/tempo");
+const PATH_USD_ADDRESS = '0x20c0000000000000000000000000000000000000';
+// secp256k1 generator point G (33 bytes) + 32-byte chaincode — valid commonKeyChain for deriveUnhardened
+const TEST_BACKUP_KEY = '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +
+    '0000000000000000000000000000000000000000000000000000000000000001';
+const TEST_RECOVERY_DESTINATION = '0x80151ebf635e6ec8a5455258f617be6cda1fbd7e';
+describe('Tempo Recovery', function () {
+    let bitgo;
+    let basecoin;
+    let sandbox;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('tempo', (b) => {
+            const mockStaticsCoin = {
+                name: 'tempo',
+                fullName: 'Tempo',
+                family: statics_1.CoinFamily.TEMPO,
+                network: { type: 'mainnet' },
+                features: [],
+            };
+            return tempo_1.Tempo.createInstance(b, mockStaticsCoin);
+        });
+        bitgo.initializeTestVars();
+        basecoin = bitgo.coin('tempo');
+    });
+    beforeEach(function () {
+        sandbox = sinon_1.default.createSandbox();
+    });
+    afterEach(function () {
+        sandbox.restore();
+    });
+    describe('queryTempoRpc (via recoveryBlockchainExplorerQuery)', function () {
+        function mockFetch(responseBody) {
+            return sandbox.stub(global, 'fetch').resolves({
+                ok: true,
+                json: async () => responseBody,
+            });
+        }
+        it('returns { result: "0" } for account/balance without calling RPC', async function () {
+            const fetchStub = mockFetch({});
+            const result = await basecoin.recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'balance',
+                address: '0xabc',
+            });
+            result.should.deepEqual({ result: '0' });
+            fetchStub.called.should.equal(false);
+        });
+        it('calls eth_call with balanceOf selector for account/tokenbalance', async function () {
+            const fetchStub = mockFetch({ result: '0x4e20' }); // 20000 decimal
+            const result = await basecoin.recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'tokenbalance',
+                address: '0x1234567890123456789012345678901234567890',
+                contractaddress: PATH_USD_ADDRESS,
+                tag: 'latest',
+            });
+            result.should.deepEqual({ result: '20000' });
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            body.method.should.equal('eth_call');
+            body.params[0].data.should.startWith('0x70a08231');
+        });
+        it('calls eth_getTransactionCount for account/txlist and parses nonce', async function () {
+            mockFetch({ result: '0x5' });
+            const result = await basecoin.recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'txlist',
+                address: '0xabc',
+            });
+            result.should.deepEqual({ nonce: 5 });
+        });
+        it('returns { result: "0" } when RPC returns null body.result', async function () {
+            mockFetch({ result: null });
+            const result = await basecoin.recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'tokenbalance',
+                address: '0xabc',
+                contractaddress: PATH_USD_ADDRESS,
+            });
+            result.should.deepEqual({ result: '0' });
+        });
+        it('returns { result: "0" } when RPC returns malformed body.result', async function () {
+            mockFetch({ result: 'not-a-number' });
+            const result = await basecoin.recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'tokenbalance',
+                address: '0xabc',
+                contractaddress: PATH_USD_ADDRESS,
+            });
+            result.should.deepEqual({ result: '0' });
+        });
+        it('throws when the RPC returns an error field', async function () {
+            mockFetch({ error: { message: 'execution reverted' } });
+            await basecoin
+                .recoveryBlockchainExplorerQuery({
+                module: 'account',
+                action: 'tokenbalance',
+                address: '0xabc',
+                contractaddress: PATH_USD_ADDRESS,
+            })
+                .should.be.rejectedWith('Tempo RPC error: execution reverted');
+        });
+        it('throws for unsupported module/action', async function () {
+            await basecoin
+                .recoveryBlockchainExplorerQuery({ module: 'proxy', action: 'eth_blockNumber' })
+                .should.be.rejectedWith('queryTempoRpc: unsupported module=proxy action=eth_blockNumber');
+        });
+    });
+    describe('buildUnsignedSweepTxnTSS — gas margin calculation', function () {
+        function stubBalanceAndNonce(balance, nonce = 0) {
+            sandbox.stub(basecoin, 'queryAddressTokenBalance').resolves(balance);
+            sandbox.stub(basecoin, 'getAddressNonce').resolves(nonce);
+        }
+        it('deducts gasLimit × maxFeePerGas / 10^12 from pathUSD balance', async function () {
+            // gasMargin = 1_000_000 * 20_000_000_000 * 1.75 / 10^12 = 35_000
+            // sweepAmount = 1_000_000 - 35_000 = 965_000
+            stubBalanceAndNonce('1000000');
+            const result = (await basecoin.buildUnsignedSweepTxnTSS({
+                backupKey: TEST_BACKUP_KEY,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+                tokenContractAddress: PATH_USD_ADDRESS,
+                gasLimit: 1000000,
+                eip1559: { maxFeePerGas: 20000000000, maxPriorityFeePerGas: 10000000000 },
+            }));
+            should_1.default.exist(result.txRequests);
+            result.txRequests[0].transactions[0].unsignedTx.should.have.property('serializedTxHex');
+        });
+        it('uses smaller margin when gasLimit is halved', async function () {
+            // gasMargin = 500_000 * 20_000_000_000 * 1.75 / 10^12 = 17_500
+            // sweepAmount = 50_000 - 17_500 = 32_500
+            stubBalanceAndNonce('50000');
+            const result = (await basecoin.buildUnsignedSweepTxnTSS({
+                backupKey: TEST_BACKUP_KEY,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+                tokenContractAddress: PATH_USD_ADDRESS,
+                gasLimit: 500000,
+                eip1559: { maxFeePerGas: 20000000000, maxPriorityFeePerGas: 10000000000 },
+            }));
+            should_1.default.exist(result.txRequests);
+        });
+        it('throws when balance exactly equals the gas margin', async function () {
+            // gasMargin = 1_000_000 * 20_000_000_000 / 10^12 = 20_000; balance = 20_000 → sweepAmount = 0
+            stubBalanceAndNonce('20000');
+            await basecoin
+                .buildUnsignedSweepTxnTSS({
+                backupKey: TEST_BACKUP_KEY,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+                tokenContractAddress: PATH_USD_ADDRESS,
+                gasLimit: 1000000,
+                eip1559: { maxFeePerGas: 20000000000, maxPriorityFeePerGas: 10000000000 },
+            })
+                .should.be.rejectedWith(/Insufficient balance/);
+        });
+        it('does not deduct margin when sweeping a non-pathUSD token', async function () {
+            const otherToken = '0x1111111111111111111111111111111111111111';
+            stubBalanceAndNonce('500');
+            const result = (await basecoin.buildUnsignedSweepTxnTSS({
+                backupKey: TEST_BACKUP_KEY,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+                tokenContractAddress: otherToken,
+                gasLimit: 1000000,
+                eip1559: { maxFeePerGas: 20000000000, maxPriorityFeePerGas: 10000000000 },
+            }));
+            // Full balance of 500 swept; no margin deducted
+            should_1.default.exist(result.txRequests);
+        });
+        it('returns correct UnsignedSweepTxMPCv2 structure', async function () {
+            stubBalanceAndNonce('1000000');
+            const result = (await basecoin.buildUnsignedSweepTxnTSS({
+                backupKey: TEST_BACKUP_KEY,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+                tokenContractAddress: PATH_USD_ADDRESS,
+                gasLimit: 1000000,
+                eip1559: { maxFeePerGas: 20000000000, maxPriorityFeePerGas: 10000000000 },
+            }));
+            const tx = result.txRequests[0].transactions[0];
+            tx.unsignedTx.derivationPath.should.equal('m/0');
+            tx.unsignedTx.coinSpecific.commonKeyChain.should.equal(TEST_BACKUP_KEY);
+            tx.signatureShares.should.deepEqual([]);
+            tx.nonce.should.equal(0);
+        });
+    });
+    describe('recoverTSS — unsigned sweep dispatch', function () {
+        it('routes to buildUnsignedSweepTxnTSS when keys are plain public keys', async function () {
+            const buildStub = sandbox.stub(basecoin, 'buildUnsignedSweepTxnTSS').resolves({ txRequests: [] });
+            sandbox.stub(basecoin, 'validateRecoveryParams').returns(undefined);
+            await basecoin.recoverTSS({
+                userKey: TEST_BACKUP_KEY,
+                backupKey: TEST_BACKUP_KEY,
+                isTss: true,
+                recoveryDestination: TEST_RECOVERY_DESTINATION,
+            });
+            buildStub.calledOnce.should.equal(true);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tempo.js","sourceRoot":"","sources":["../../../test/unit/tempo.ts"],"names":[],"mappings":"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","sourcesContent":["import sinon from 'sinon';\nimport should from 'should';\nimport { BitGoAPI } from '@bitgo/sdk-api';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo/sdk-test';\nimport { BitGoBase } from '@bitgo/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily } from '@bitgo/statics';\nimport { Tempo } from '../../src/tempo';\nconst PATH_USD_ADDRESS = '0x20c0000000000000000000000000000000000000';\n\n// secp256k1 generator point G (33 bytes) + 32-byte chaincode — valid commonKeyChain for deriveUnhardened\nconst TEST_BACKUP_KEY =\n  '0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798' +\n  '0000000000000000000000000000000000000000000000000000000000000001';\nconst TEST_RECOVERY_DESTINATION = '0x80151ebf635e6ec8a5455258f617be6cda1fbd7e';\n\ndescribe('Tempo Recovery', function () {\n  let bitgo: TestBitGoAPI;\n  let basecoin: Tempo;\n  let sandbox: sinon.SinonSandbox;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('tempo', (b: BitGoBase) => {\n      const mockStaticsCoin: Readonly<StaticsBaseCoin> = {\n        name: 'tempo',\n        fullName: 'Tempo',\n        family: CoinFamily.TEMPO,\n        network: { type: 'mainnet' },\n        features: [],\n      } as any;\n      return Tempo.createInstance(b, mockStaticsCoin);\n    });\n    bitgo.initializeTestVars();\n    basecoin = bitgo.coin('tempo') as Tempo;\n  });\n\n  beforeEach(function () {\n    sandbox = sinon.createSandbox();\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  describe('queryTempoRpc (via recoveryBlockchainExplorerQuery)', function () {\n    function mockFetch(responseBody: Record<string, unknown>): sinon.SinonStub {\n      return sandbox.stub(global, 'fetch' as any).resolves({\n        ok: true,\n        json: async () => responseBody,\n      } as any);\n    }\n\n    it('returns { result: \"0\" } for account/balance without calling RPC', async function () {\n      const fetchStub = mockFetch({});\n      const result = await basecoin.recoveryBlockchainExplorerQuery({\n        module: 'account',\n        action: 'balance',\n        address: '0xabc',\n      });\n      result.should.deepEqual({ result: '0' });\n      fetchStub.called.should.equal(false);\n    });\n\n    it('calls eth_call with balanceOf selector for account/tokenbalance', async function () {\n      const fetchStub = mockFetch({ result: '0x4e20' }); // 20000 decimal\n      const result = await basecoin.recoveryBlockchainExplorerQuery({\n        module: 'account',\n        action: 'tokenbalance',\n        address: '0x1234567890123456789012345678901234567890',\n        contractaddress: PATH_USD_ADDRESS,\n        tag: 'latest',\n      });\n      result.should.deepEqual({ result: '20000' });\n      const body = JSON.parse(fetchStub.firstCall.args[1].body);\n      body.method.should.equal('eth_call');\n      body.params[0].data.should.startWith('0x70a08231');\n    });\n\n    it('calls eth_getTransactionCount for account/txlist and parses nonce', async function () {\n      mockFetch({ result: '0x5' });\n      const result = await basecoin.recoveryBlockchainExplorerQuery({\n        module: 'account',\n        action: 'txlist',\n        address: '0xabc',\n      });\n      result.should.deepEqual({ nonce: 5 });\n    });\n\n    it('returns { result: \"0\" } when RPC returns null body.result', async function () {\n      mockFetch({ result: null });\n      const result = await basecoin.recoveryBlockchainExplorerQuery({\n        module: 'account',\n        action: 'tokenbalance',\n        address: '0xabc',\n        contractaddress: PATH_USD_ADDRESS,\n      });\n      result.should.deepEqual({ result: '0' });\n    });\n\n    it('returns { result: \"0\" } when RPC returns malformed body.result', async function () {\n      mockFetch({ result: 'not-a-number' });\n      const result = await basecoin.recoveryBlockchainExplorerQuery({\n        module: 'account',\n        action: 'tokenbalance',\n        address: '0xabc',\n        contractaddress: PATH_USD_ADDRESS,\n      });\n      result.should.deepEqual({ result: '0' });\n    });\n\n    it('throws when the RPC returns an error field', async function () {\n      mockFetch({ error: { message: 'execution reverted' } });\n      await basecoin\n        .recoveryBlockchainExplorerQuery({\n          module: 'account',\n          action: 'tokenbalance',\n          address: '0xabc',\n          contractaddress: PATH_USD_ADDRESS,\n        })\n        .should.be.rejectedWith('Tempo RPC error: execution reverted');\n    });\n\n    it('throws for unsupported module/action', async function () {\n      await basecoin\n        .recoveryBlockchainExplorerQuery({ module: 'proxy', action: 'eth_blockNumber' })\n        .should.be.rejectedWith('queryTempoRpc: unsupported module=proxy action=eth_blockNumber');\n    });\n  });\n\n  describe('buildUnsignedSweepTxnTSS — gas margin calculation', function () {\n    function stubBalanceAndNonce(balance: string, nonce = 0) {\n      sandbox.stub(basecoin as any, 'queryAddressTokenBalance').resolves(balance);\n      sandbox.stub(basecoin as any, 'getAddressNonce').resolves(nonce);\n    }\n\n    it('deducts gasLimit × maxFeePerGas / 10^12 from pathUSD balance', async function () {\n      // gasMargin = 1_000_000 * 20_000_000_000 * 1.75 / 10^12 = 35_000\n      // sweepAmount = 1_000_000 - 35_000 = 965_000\n      stubBalanceAndNonce('1000000');\n      const result = (await (basecoin as any).buildUnsignedSweepTxnTSS({\n        backupKey: TEST_BACKUP_KEY,\n        recoveryDestination: TEST_RECOVERY_DESTINATION,\n        tokenContractAddress: PATH_USD_ADDRESS,\n        gasLimit: 1_000_000,\n        eip1559: { maxFeePerGas: 20_000_000_000, maxPriorityFeePerGas: 10_000_000_000 },\n      })) as any;\n      should.exist(result.txRequests);\n      result.txRequests[0].transactions[0].unsignedTx.should.have.property('serializedTxHex');\n    });\n\n    it('uses smaller margin when gasLimit is halved', async function () {\n      // gasMargin = 500_000 * 20_000_000_000 * 1.75 / 10^12 = 17_500\n      // sweepAmount = 50_000 - 17_500 = 32_500\n      stubBalanceAndNonce('50000');\n      const result = (await (basecoin as any).buildUnsignedSweepTxnTSS({\n        backupKey: TEST_BACKUP_KEY,\n        recoveryDestination: TEST_RECOVERY_DESTINATION,\n        tokenContractAddress: PATH_USD_ADDRESS,\n        gasLimit: 500_000,\n        eip1559: { maxFeePerGas: 20_000_000_000, maxPriorityFeePerGas: 10_000_000_000 },\n      })) as any;\n      should.exist(result.txRequests);\n    });\n\n    it('throws when balance exactly equals the gas margin', async function () {\n      // gasMargin = 1_000_000 * 20_000_000_000 / 10^12 = 20_000; balance = 20_000 → sweepAmount = 0\n      stubBalanceAndNonce('20000');\n      await (basecoin as any)\n        .buildUnsignedSweepTxnTSS({\n          backupKey: TEST_BACKUP_KEY,\n          recoveryDestination: TEST_RECOVERY_DESTINATION,\n          tokenContractAddress: PATH_USD_ADDRESS,\n          gasLimit: 1_000_000,\n          eip1559: { maxFeePerGas: 20_000_000_000, maxPriorityFeePerGas: 10_000_000_000 },\n        })\n        .should.be.rejectedWith(/Insufficient balance/);\n    });\n\n    it('does not deduct margin when sweeping a non-pathUSD token', async function () {\n      const otherToken = '0x1111111111111111111111111111111111111111';\n      stubBalanceAndNonce('500');\n      const result = (await (basecoin as any).buildUnsignedSweepTxnTSS({\n        backupKey: TEST_BACKUP_KEY,\n        recoveryDestination: TEST_RECOVERY_DESTINATION,\n        tokenContractAddress: otherToken,\n        gasLimit: 1_000_000,\n        eip1559: { maxFeePerGas: 20_000_000_000, maxPriorityFeePerGas: 10_000_000_000 },\n      })) as any;\n      // Full balance of 500 swept; no margin deducted\n      should.exist(result.txRequests);\n    });\n\n    it('returns correct UnsignedSweepTxMPCv2 structure', async function () {\n      stubBalanceAndNonce('1000000');\n      const result = (await (basecoin as any).buildUnsignedSweepTxnTSS({\n        backupKey: TEST_BACKUP_KEY,\n        recoveryDestination: TEST_RECOVERY_DESTINATION,\n        tokenContractAddress: PATH_USD_ADDRESS,\n        gasLimit: 1_000_000,\n        eip1559: { maxFeePerGas: 20_000_000_000, maxPriorityFeePerGas: 10_000_000_000 },\n      })) as any;\n      const tx = result.txRequests[0].transactions[0];\n      tx.unsignedTx.derivationPath.should.equal('m/0');\n      tx.unsignedTx.coinSpecific.commonKeyChain.should.equal(TEST_BACKUP_KEY);\n      tx.signatureShares.should.deepEqual([]);\n      tx.nonce.should.equal(0);\n    });\n  });\n\n  describe('recoverTSS — unsigned sweep dispatch', function () {\n    it('routes to buildUnsignedSweepTxnTSS when keys are plain public keys', async function () {\n      const buildStub = sandbox.stub(basecoin as any, 'buildUnsignedSweepTxnTSS').resolves({ txRequests: [] });\n      sandbox.stub(basecoin as any, 'validateRecoveryParams').returns(undefined);\n\n      await (basecoin as any).recoverTSS({\n        userKey: TEST_BACKUP_KEY,\n        backupKey: TEST_BACKUP_KEY,\n        isTss: true,\n        recoveryDestination: TEST_RECOVERY_DESTINATION,\n      });\n\n      buildStub.calledOnce.should.equal(true);\n    });\n  });\n});\n"]}