@bitgo-beta/sdk-coin-polyx 1.0.1-beta.13 → 1.0.1-beta.1300

package/dist/test/unit/polyx.js

@@ -0,0 +1,603 @@
+"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;
+    };
+})();
+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 sdk_test_1 = require("@bitgo-beta/sdk-test");
+const sdk_api_1 = require("@bitgo-beta/sdk-api");
+const src_1 = require("../../src");
+const constants_1 = require("../../src/lib/constants");
+const utils_1 = __importDefault(require("../../src/lib/utils"));
+const statics_1 = require("@bitgo-beta/statics");
+const sinon = __importStar(require("sinon"));
+const testData = __importStar(require("../resources/wrwUsers"));
+const mocha_1 = require("mocha");
+const resources_1 = require("../resources");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const lib_1 = require("../../src/lib");
+const resources_2 = require("../../src/resources");
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+describe('Polyx:', function () {
+    let bitgo;
+    let baseCoin;
+    before(function () {
+        bitgo = sdk_test_1.TestBitGo.decorate(sdk_api_1.BitGoAPI, { env: 'mock' });
+        bitgo.safeRegister('polyx', src_1.Polyx.createInstance);
+        bitgo.safeRegister('tpolyx', src_1.Tpolyx.createInstance);
+        bitgo.initializeTestVars();
+        baseCoin = bitgo.coin('tpolyx');
+    });
+    describe('Address Format Constants', function () {
+        it('should have the correct address format constants', function () {
+            // Verify the constants are defined correctly
+            constants_1.POLYX_ADDRESS_FORMAT.should.equal(12);
+            constants_1.TPOLYX_ADDRESS_FORMAT.should.equal(42);
+        });
+    });
+    describe('Recover Transactions:', function () {
+        const sandBox = sinon.createSandbox();
+        const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';
+        const nonce = 0;
+        let accountInfoCB;
+        let headerInfoCB;
+        let getFeeCB;
+        let getMaterialCB;
+        beforeEach(function () {
+            accountInfoCB = sandBox.stub(src_1.Polyx.prototype, 'getAccountInfo');
+            headerInfoCB = sandBox.stub(src_1.Polyx.prototype, 'getHeaderInfo');
+            getFeeCB = sandBox.stub(src_1.Polyx.prototype, 'getFee');
+            getMaterialCB = sandBox.stub(src_1.Polyx.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tpolyx').network.type));
+        });
+        (0, mocha_1.afterEach)(function () {
+            sandBox.restore();
+        });
+        it('should generate unsigned sweep correctly', async function () {
+            accountInfoCB
+                .withArgs(testData.unsignedSweepUser.walletAddress)
+                .resolves({ nonce: 0, freeBalance: 100007000000 });
+            headerInfoCB.resolves({
+                headerNumber: testData.testnetBlock.blockNumber,
+                headerHash: testData.testnetBlock.hash,
+            });
+            getFeeCB.withArgs(recoveryDestination, testData.unsignedSweepUser.walletAddress, 100007000000).resolves(74401);
+            const commonKeyChain = testData.unsignedSweepUser.bitgoKey;
+            const unsigned = await baseCoin.recover({ bitgoKey: commonKeyChain, recoveryDestination });
+            unsigned.txRequests.should.not.be.undefined();
+            unsigned.txRequests.length.should.equal(1);
+            unsigned.txRequests[0].transactions.length.should.equal(1);
+            unsigned.txRequests[0].walletCoin.should.equal('tpolyx');
+            unsigned.txRequests[0].transactions[0].unsignedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.serializedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.scanIndex.should.equal(0);
+            unsigned.txRequests[0].transactions[0].unsignedTx.coin.should.equal('tpolyx');
+            unsigned.txRequests[0].transactions[0].unsignedTx.signableHex.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.derivationPath.should.equal('m/0');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.length.should.equal(1);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].address.should.equal('5DnZQqbxtB3CWkLgfA6wpqdkCd9Bq7AX49RpLPJwW9mzoT7s');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].valueString.should.equal('100006255990');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].value.should.equal(100006255990);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.length.should.equal(1);
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].address.should.equal('5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].valueString.should.equal('100006255990');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].coinName.should.equal('tpolyx');
+            unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.type.should.equal('');
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.fee.should.equal(0);
+            unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.feeString.should.equal('0');
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.firstValid.should.not.be.undefined();
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.maxDuration.should.equal(2400);
+            unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.commonKeychain.should.equal('97d9da8bf544d07f3c7ae8ee06bb12a63f74478d0c461201ab94421a9c81d5b379553f0332daaa85cb8c65e1fe7e6907c62268c00812b08a4e1361178e304ddb');
+        });
+        it('should recover a tx for non-bitgo recoveries', async function () {
+            accountInfoCB.withArgs(testData.wrwUser.walletAddress).resolves({ nonce: 0, freeBalance: 100007000000 });
+            headerInfoCB.resolves({
+                headerNumber: testData.testnetBlock.blockNumber,
+                headerHash: testData.testnetBlock.hash,
+            });
+            getFeeCB.withArgs(recoveryDestination, testData.wrwUser.walletAddress, 100007000000).resolves(74401);
+            const res = await baseCoin.recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination: recoveryDestination,
+            });
+            res.should.not.be.empty();
+            res.should.hasOwnProperty('serializedTx');
+            res.should.hasOwnProperty('scanIndex');
+            const txBuilder = baseCoin.getBuilder().from(res.serializedTx);
+            txBuilder
+                .validity({
+                firstValid: testData.testnetBlock.blockNumber,
+                maxDuration: baseCoin.SWEEP_TXN_DURATION,
+            })
+                .referenceBlock(testData.testnetBlock.hash);
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            should_1.default.deepEqual(txJson.sender, testData.wrwUser.walletAddress);
+            should_1.default.deepEqual(txJson.blockNumber, testData.testnetBlock.blockNumber);
+            should_1.default.deepEqual(txJson.referenceBlock, testData.testnetBlock.hash);
+            should_1.default.deepEqual(txJson.genesisHash, resources_1.genesisHash);
+            should_1.default.deepEqual(txJson.specVersion, resources_1.specVersion);
+            should_1.default.deepEqual(txJson.nonce, nonce);
+            should_1.default.deepEqual(txJson.tip, 0);
+            should_1.default.deepEqual(txJson.transactionVersion, resources_1.txVersion);
+            should_1.default.deepEqual(txJson.eraPeriod, baseCoin.SWEEP_TXN_DURATION);
+        });
+        it('should recover a txn for unsigned-sweep recoveries', async function () {
+            accountInfoCB
+                .withArgs(testData.unsignedSweepUser.walletAddress)
+                .resolves({ nonce: 0, freeBalance: 100007000000 });
+            headerInfoCB.resolves({
+                headerNumber: testData.testnetBlock.blockNumber,
+                headerHash: testData.testnetBlock.hash,
+            });
+            getFeeCB.withArgs(recoveryDestination, testData.unsignedSweepUser.walletAddress, 100007000000).resolves(74401);
+            const res = await baseCoin.recover({
+                bitgoKey: testData.unsignedSweepUser.bitgoKey,
+                recoveryDestination: recoveryDestination,
+            });
+            res.should.not.be.empty();
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');
+            res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');
+            const txBuilder = baseCoin.getBuilder().from(res.txRequests[0].transactions[0].unsignedTx.serializedTx);
+            txBuilder
+                .validity({
+                firstValid: testData.testnetBlock.blockNumber,
+                maxDuration: baseCoin.SWEEP_TXN_DURATION,
+            })
+                .referenceBlock(testData.testnetBlock.hash)
+                .sender({ address: testData.unsignedSweepUser.walletAddress });
+            const tx = await txBuilder.build();
+            const txJson = tx.toJson();
+            should_1.default.deepEqual(txJson.sender, testData.unsignedSweepUser.walletAddress);
+            should_1.default.deepEqual(txJson.blockNumber, testData.testnetBlock.blockNumber);
+            should_1.default.deepEqual(txJson.referenceBlock, testData.testnetBlock.hash);
+            should_1.default.deepEqual(txJson.genesisHash, resources_1.genesisHash);
+            should_1.default.deepEqual(txJson.specVersion, resources_1.specVersion);
+            should_1.default.deepEqual(txJson.nonce, 0);
+            should_1.default.deepEqual(txJson.tip, 0);
+            should_1.default.deepEqual(txJson.transactionVersion, resources_1.txVersion);
+            should_1.default.deepEqual(txJson.eraPeriod, baseCoin.SWEEP_TXN_DURATION);
+        });
+        describe('MPCv2 signed recovery', function () {
+            const walletPassphrase = 'test-passphrase-mpcv2';
+            let mpcV2UserKey;
+            let mpcV2BackupKey;
+            let mpcV2CommonKeyChain;
+            let mpcV2RecoverParams;
+            before(async function () {
+                const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+                mpcV2CommonKeyChain = userDkg.getCommonKeychain();
+                mpcV2UserKey = await (0, sdk_api_1.encrypt)(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));
+                mpcV2BackupKey = await (0, sdk_api_1.encrypt)(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));
+                mpcV2RecoverParams = {
+                    userKey: mpcV2UserKey,
+                    backupKey: mpcV2BackupKey,
+                    bitgoKey: mpcV2CommonKeyChain,
+                    recoveryDestination,
+                    walletPassphrase,
+                };
+            });
+            beforeEach(function () {
+                // Use unrestricted resolves (not .withArgs) since the mismatched-bitgoKey test
+                // derives a different sender address than mpcV2WalletAddress.
+                accountInfoCB.resolves({ nonce: 0, freeBalance: 100007000000 });
+                headerInfoCB.resolves({
+                    headerNumber: testData.testnetBlock.blockNumber,
+                    headerHash: testData.testnetBlock.hash,
+                });
+                getFeeCB.resolves(74401);
+            });
+            it('should recover a tx using MPCv2 signing material', async function () {
+                const getTSSSignatureSpy = sandBox.spy(sdk_core_1.EDDSAMethods, 'getTSSSignature');
+                const addSignatureSpy = sandBox.spy(lib_1.TransferBuilder.prototype, 'addSignature');
+                const result = (await baseCoin.recover(mpcV2RecoverParams));
+                result.should.not.be.empty();
+                result.should.hasOwnProperty('serializedTx');
+                result.should.hasOwnProperty('scanIndex');
+                should_1.default.equal(result.scanIndex, 0);
+                result.serializedTx.should.be.a.String().and.not.be.empty();
+                sandBox.assert.notCalled(getTSSSignatureSpy);
+                sandBox.assert.calledOnce(addSignatureSpy);
+                const signature = addSignatureSpy.firstCall.args[1];
+                // constructSignedPayload prepends the 0x00 Ed25519 discriminant internally;
+                // recover() must pass the raw 64-byte signature unchanged.
+                signature.length.should.equal(64);
+            });
+            it('should produce a cryptographically valid Ed25519 signature', async function () {
+                const addSignatureSpy = sandBox.spy(lib_1.TransferBuilder.prototype, 'addSignature');
+                const signRecoverySpy = sandBox.spy(baseCoin, 'signSubstrateMpcV2Recovery');
+                await baseCoin.recover(mpcV2RecoverParams);
+                // 65-byte sig: 0x00 discriminant + 64-byte Ed25519 sig; signatureVerify handles the prefix.
+                const signature = addSignatureSpy.firstCall.args[1];
+                // Capture the exact bytes signed by the DSG protocol inside signSubstrateMpcV2Recovery.
+                const signablePayload = signRecoverySpy.firstCall.args[0].message;
+                const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+                const accountId = MPC.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64);
+                const senderAddr = baseCoin.getAddressFromPublicKey(accountId);
+                const isValid = utils_1.default.verifySignature(`0x${signablePayload.toString('hex')}`, `0x${signature.toString('hex')}`, senderAddr);
+                isValid.should.be.true();
+            });
+            it('should use MPCv1 path when signing material is MPCv1 format', async function () {
+                const userPrv = JSON.stringify({ uShare: { seed: 'aa' }, bitgoYShare: { u: 'bb' }, backupYShare: { u: 'cc' } });
+                sandBox
+                    .stub(baseCoin, 'getEddsaSigningMaterial')
+                    .resolves({ version: 'v1', userPrv });
+                const getTSSSignatureStub = sandBox
+                    .stub(sdk_core_1.EDDSAMethods, 'getTSSSignature')
+                    .resolves(Buffer.from('1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9da' +
+                    'e1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857', 'hex'));
+                sandBox
+                    .stub(bitgo, 'decrypt')
+                    .withArgs(sinon.match({ input: mpcV2BackupKey.replace(/\s/g, '') }))
+                    .resolves(JSON.stringify({ bShare: {}, yShares: {} }));
+                const result = (await baseCoin.recover(mpcV2RecoverParams));
+                result.should.not.be.empty();
+                result.should.hasOwnProperty('serializedTx');
+                result.should.hasOwnProperty('scanIndex');
+                should_1.default.equal(result.scanIndex, 0);
+                result.serializedTx.should.be.a.String().and.not.be.empty();
+                sandBox.assert.calledOnce(getTSSSignatureStub);
+            });
+            it('should throw a descriptive error when user keychain decryption fails on the MPCv1 path', async function () {
+                sandBox.stub(bitgo, 'decrypt').rejects(new Error('password error'));
+                await baseCoin.recover(mpcV2RecoverParams).should.be.rejectedWith(/Error decrypting user keychain/);
+            });
+            it('should throw when commonKeyChain from MPCv2 keycard does not match bitgoKey', async function () {
+                const mismatchedBitgoKey = mpcV2CommonKeyChain.slice(0, -8) + '00000000';
+                const mismatchedParams = {
+                    ...mpcV2RecoverParams,
+                    bitgoKey: mismatchedBitgoKey,
+                };
+                await baseCoin
+                    .recover(mismatchedParams)
+                    .should.be.rejectedWith('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');
+            });
+            it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {
+                const paramsWithoutUserKey = { ...mpcV2RecoverParams, userKey: undefined };
+                await baseCoin.recover(paramsWithoutUserKey).should.be.rejectedWith('missing userKey');
+            });
+            it('should throw missing backupKey when userKey and walletPassphrase are present but backupKey is not', async function () {
+                const paramsWithoutBackupKey = { ...mpcV2RecoverParams, backupKey: undefined };
+                await baseCoin.recover(paramsWithoutBackupKey).should.be.rejectedWith('missing backupKey');
+            });
+            it('should throw missing wallet passphrase when userKey and backupKey are present but walletPassphrase is not', async function () {
+                const paramsWithoutPassphrase = { ...mpcV2RecoverParams, walletPassphrase: undefined };
+                await baseCoin.recover(paramsWithoutPassphrase).should.be.rejectedWith('missing wallet passphrase');
+            });
+            it('should pass the raw 64-byte signature to addSignature on MPCv2 path', async function () {
+                // Regression: previously wrapped rawSig with a manual Ed25519 discriminant (0x00)
+                // before addSignature. constructSignedPayload already prepends that discriminant,
+                // so wrapping here caused a double prefix that shifted the on-wire signature by
+                // one byte, dropping the last byte of sigma and producing
+                // `1010: Bad signature` on-chain.
+                const rawSig = Buffer.alloc(64, 0xab);
+                sandBox
+                    .stub(baseCoin, 'signSubstrateMpcV2Recovery')
+                    .resolves(rawSig);
+                const addSignatureSpy = sandBox.spy(lib_1.TransferBuilder.prototype, 'addSignature');
+                await baseCoin.recover(mpcV2RecoverParams);
+                sandBox.assert.calledOnce(addSignatureSpy);
+                const sig = addSignatureSpy.firstCall.args[1];
+                sig.length.should.equal(64);
+                sig.should.deepEqual(rawSig);
+            });
+        });
+    });
+    describe('Recover Transaction Failures:', function () {
+        const sandBox = sinon.createSandbox();
+        const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';
+        beforeEach(function () {
+            sandBox.stub(src_1.Polyx.prototype, 'getAccountInfo').resolves({ nonce: 0, freeBalance: 0 });
+            sandBox.stub(src_1.Polyx.prototype, 'getFee').resolves(74401);
+        });
+        (0, mocha_1.afterEach)(function () {
+            sandBox.restore();
+        });
+        it('should fail to recover due to not finding an address with funds', async function () {
+            await baseCoin
+                .recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination,
+            })
+                .should.rejectedWith(sdk_core_1.ErrorNoInputToRecover);
+        });
+        it('should throw RecoveryProviderError when account info query fails', async function () {
+            src_1.Polyx.prototype.getAccountInfo.rejects(new Error('network failure'));
+            await baseCoin
+                .recover({
+                userKey: testData.wrwUser.userKey,
+                backupKey: testData.wrwUser.backupKey,
+                bitgoKey: testData.wrwUser.bitgoKey,
+                walletPassphrase: testData.wrwUser.walletPassphrase,
+                recoveryDestination,
+            })
+                .should.be.rejectedWith(sdk_core_1.RecoveryProviderError);
+        });
+    });
+    describe('Token Enablement:', function () {
+        it('should have correct token enablement config', function () {
+            const config = baseCoin.getTokenEnablementConfig();
+            should_1.default.exist(config);
+            config.requiresTokenEnablement.should.equal(true);
+            config.supportsMultipleTokenEnablements.should.equal(false);
+        });
+        it('should validate wallet type for token enablement', function () {
+            const config = baseCoin.getTokenEnablementConfig();
+            (() => config.validateWallet('custodial')).should.not.throw();
+            (() => config.validateWallet('hot')).should.throw(/Token enablement for Polymesh \(polyx\) is only supported for custodial wallets/);
+            (() => config.validateWallet('cold')).should.throw(/Token enablement for Polymesh \(polyx\) is only supported for custodial wallets/);
+        });
+    });
+    describe('verifyTransaction', function () {
+        const transferTo = '5F8jxKE81GhFrphyfMFr5UjeAz5wS4AaZFmeFPnf8wTetD72';
+        const transferAmount = '2000000000';
+        const wrongAddress = '5GhbC6n2pUFrX98DwyPit67fB5AwQvVCwZ4j2HKA7a4dUK4y';
+        describe('transfer transaction', function () {
+            it('should return true when address and amount match', async function () {
+                const result = await baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.transfer.signed },
+                    txParams: { recipients: [{ address: transferTo, amount: transferAmount }] },
+                });
+                result.should.be.true();
+            });
+            it('should throw TxIntentMismatchRecipientError for address mismatch', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.transfer.signed },
+                    txParams: { recipients: [{ address: wrongAddress, amount: transferAmount }] },
+                })
+                    .should.be.rejectedWith(sdk_core_1.TxIntentMismatchRecipientError);
+            });
+            it('should throw TxIntentMismatchRecipientError for amount mismatch', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.transfer.signed },
+                    txParams: { recipients: [{ address: transferTo, amount: '1' }] },
+                })
+                    .should.be.rejectedWith(sdk_core_1.TxIntentMismatchRecipientError);
+            });
+        });
+        describe('guard cases', function () {
+            it('should throw when txHex is missing', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: {},
+                    txParams: { recipients: [{ address: transferTo, amount: transferAmount }] },
+                })
+                    .should.be.rejectedWith('missing txHex in txPrebuild');
+            });
+            it('should throw when recipients has more than 1 entry', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.transfer.signed },
+                    txParams: {
+                        recipients: [
+                            { address: transferTo, amount: transferAmount },
+                            { address: wrongAddress, amount: transferAmount },
+                        ],
+                    },
+                })
+                    .should.be.rejectedWith(/support sending to more than 1 destination address/);
+            });
+            it('should throw when recipients is an empty array', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.transfer.signed },
+                    txParams: { recipients: [] },
+                })
+                    .should.be.rejectedWith('missing recipients in txParams');
+            });
+        });
+        describe('token enablement (preApproveAsset) transaction', function () {
+            it('should return true for enabletoken type with recipients (wallet root address)', async function () {
+                // buildTokenEnablements sets recipients[0].address = wallet rootAddress and type = 'enabletoken'.
+                // verifyTransaction must short-circuit before the _to check since preApproveAsset has no destination.
+                const walletAddress = '5F8jxKE81GhFrphyfMFr5UjeAz5wS4AaZFmeFPnf8wTetD72';
+                const result = await baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.preApproveAsset.signed },
+                    txParams: {
+                        type: 'enabletoken',
+                        recipients: [{ address: walletAddress, amount: '0', tokenName: 'tpolyx:sometoken' }],
+                    },
+                });
+                result.should.be.true();
+            });
+            it('should return true for enabletoken type with no recipients', async function () {
+                const result = await baseCoin.verifyTransaction({
+                    txPrebuild: { txHex: resources_1.rawTx.preApproveAsset.signed },
+                    txParams: { type: 'enabletoken' },
+                });
+                result.should.be.true();
+            });
+        });
+        describe('v8 transfer with coinSpecific.material', function () {
+            const v8Amount = '1000000';
+            const v8Receiver = resources_1.accounts.account2;
+            const v8Sender = resources_1.accounts.account1;
+            let v8SignedTxHex;
+            before(async function () {
+                // Build a signed v8 transfer tx using testnetV8Material.
+                // The server embeds this material in coinSpecific during prebuild so that
+                // verifyTransaction can decode txHex built against a chain spec newer than
+                // the SDK's hardcoded v7 material (CECHO-1471).
+                const builder = new lib_1.V8TransferBuilder(statics_1.coins.get('tpolyx'))
+                    .amount(v8Amount)
+                    .to({ address: v8Receiver.address })
+                    .sender({ address: v8Sender.address })
+                    .memo('0')
+                    .validity({ firstValid: 3933, maxDuration: 64 })
+                    .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')
+                    .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 1 })
+                    .fee({ amount: 0, type: 'tip' });
+                builder.addSignature({ pub: v8Sender.publicKey }, Buffer.from(resources_1.mockTssSignature, 'hex'));
+                const tx = await builder.build();
+                v8SignedTxHex = tx.toBroadcastFormat();
+            });
+            it('verifies a v8 transfer when coinSpecific.material is provided', async function () {
+                const result = await baseCoin.verifyTransaction({
+                    txPrebuild: {
+                        txHex: v8SignedTxHex,
+                        coinSpecific: { material: resources_2.testnetV8Material },
+                    },
+                    txParams: { recipients: [{ address: v8Receiver.address, amount: v8Amount }] },
+                });
+                result.should.be.true();
+            });
+            it('throws TxIntentMismatchRecipientError for address mismatch on v8 transfer', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: {
+                        txHex: v8SignedTxHex,
+                        coinSpecific: { material: resources_2.testnetV8Material },
+                    },
+                    txParams: { recipients: [{ address: wrongAddress, amount: v8Amount }] },
+                })
+                    .should.be.rejectedWith(sdk_core_1.TxIntentMismatchRecipientError);
+            });
+            it('throws TxIntentMismatchRecipientError for amount mismatch on v8 transfer', async function () {
+                await baseCoin
+                    .verifyTransaction({
+                    txPrebuild: {
+                        txHex: v8SignedTxHex,
+                        coinSpecific: { material: resources_2.testnetV8Material },
+                    },
+                    txParams: { recipients: [{ address: v8Receiver.address, amount: '1' }] },
+                })
+                    .should.be.rejectedWith(sdk_core_1.TxIntentMismatchRecipientError);
+            });
+        });
+    });
+    describe('createBroadcastableSweepTransaction (MPCv2):', () => {
+        const sandBox = sinon.createSandbox();
+        let userKeyShare;
+        let backupKeyShare;
+        let commonKeychain;
+        let mpcv2SweepTxRequest;
+        let mpcv2SignatureHex;
+        before(async function () {
+            const [userDkg, backupDkg] = await sdk_lib_mpc_1.MPSUtil.generateEdDsaDKGKeyShares();
+            commonKeychain = userDkg.getCommonKeychain();
+            userKeyShare = userDkg.getKeyShare();
+            backupKeyShare = backupDkg.getKeyShare();
+            const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';
+            const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const walletAddress = baseCoin.getAddressFromPublicKey(mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64));
+            const accountInfoCB = sandBox.stub(src_1.Polyx.prototype, 'getAccountInfo');
+            accountInfoCB.withArgs(walletAddress).resolves({ nonce: 0, freeBalance: 100007000000 });
+            const headerInfoCB = sandBox.stub(src_1.Polyx.prototype, 'getHeaderInfo');
+            headerInfoCB.resolves({
+                headerNumber: testData.testnetBlock.blockNumber,
+                headerHash: testData.testnetBlock.hash,
+            });
+            const getFeeCB = sandBox.stub(src_1.Polyx.prototype, 'getFee');
+            getFeeCB.withArgs(recoveryDestination, walletAddress, 100007000000).resolves(74401);
+            const getMaterialCB = sandBox.stub(src_1.Polyx.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tpolyx').network.type));
+            // no walletPassphrase -> unsigned sweep path returns MPCSweepTxs
+            const sweep = (await baseCoin.recover({
+                bitgoKey: commonKeychain,
+                recoveryDestination,
+            }));
+            sandBox.restore();
+            mpcv2SweepTxRequest = sweep.txRequests[0];
+            const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;
+            const signature = await (0, sdk_core_1.signRecoveryEddsaMPCv2)(Buffer.from(unsignedTx.signableHex, 'hex'), unsignedTx.derivationPath, userKeyShare, backupKeyShare, commonKeychain);
+            mpcv2SignatureHex = signature.toString('hex');
+        });
+        // createBroadcastableSweepTransaction calls getMaterial() to re-encode the signed
+        // transaction; stub it with the same testnet material the sweep was built with.
+        beforeEach(function () {
+            const getMaterialCB = sandBox.stub(src_1.Polyx.prototype, 'getMaterial');
+            getMaterialCB.resolves(utils_1.default.getMaterial(statics_1.coins.get('tpolyx').network.type));
+        });
+        (0, mocha_1.afterEach)(function () {
+            sandBox.restore();
+        });
+        function buildParams(ovc) {
+            return {
+                signatureShares: [
+                    {
+                        txRequest: mpcv2SweepTxRequest,
+                        tssVersion: '0.0.1',
+                        ovc: [ovc],
+                    },
+                ],
+            };
+        }
+        it('should take MPCv2 OVC output and generate a signed sweep transaction', async function () {
+            const params = buildParams({ eddsaMpcv2Signature: mpcv2SignatureHex });
+            const recoveryTxn = await baseCoin.createBroadcastableSweepTransaction(params);
+            recoveryTxn.transactions[0].serializedTx.should.not.equal(mpcv2SweepTxRequest.transactions[0].unsignedTx.serializedTx);
+            recoveryTxn.transactions[0].serializedTx.should.not.be.empty();
+            (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);
+            (recoveryTxn.lastScanIndex ?? 0).should.equal(0);
+        });
+        it('should reject a tampered MPCv2 signature', async function () {
+            const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;
+            const tamperedMessage = Buffer.concat([Buffer.from(unsignedTx.signableHex, 'hex'), Buffer.from('00', 'hex')]);
+            const tamperedSignature = await (0, sdk_core_1.signRecoveryEddsaMPCv2)(tamperedMessage, unsignedTx.derivationPath, userKeyShare, backupKeyShare, commonKeychain);
+            await baseCoin
+                .createBroadcastableSweepTransaction(buildParams({ eddsaMpcv2Signature: tamperedSignature.toString('hex') }))
+                .should.be.rejectedWith('Invalid signature');
+        });
+        it('should throw when MPCv2 OVC is missing signature(s)', async function () {
+            await baseCoin
+                .createBroadcastableSweepTransaction(buildParams({}))
+                .should.be.rejectedWith('Missing signature(s)');
+        });
+        it('should route MPCv1-shaped ovc to the MPCv1 verify branch and reject an invalid signature', async function () {
+            const mpc = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const derivedPubKey = mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64);
+            await baseCoin
+                .createBroadcastableSweepTransaction(buildParams({
+                eddsaSignature: { R: '00'.repeat(32), sigma: '00'.repeat(32), y: derivedPubKey },
+            }))
+                .should.be.rejectedWith('Invalid signature');
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polyx.js","sourceRoot":"","sources":["../../../test/unit/polyx.ts"],"names":[],"mappings":"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","sourcesContent":["import should from 'should';\nimport { TestBitGo, TestBitGoAPI } from '@bitgo-beta/sdk-test';\nimport { BitGoAPI, encrypt } from '@bitgo-beta/sdk-api';\nimport { Polyx, Tpolyx } from '../../src';\nimport { POLYX_ADDRESS_FORMAT, TPOLYX_ADDRESS_FORMAT } from '../../src/lib/constants';\nimport utils from '../../src/lib/utils';\nimport { coins } from '@bitgo-beta/statics';\nimport * as sinon from 'sinon';\nimport * as testData from '../resources/wrwUsers';\nimport { afterEach } from 'mocha';\nimport { genesisHash, specVersion, txVersion, rawTx, accounts, mockTssSignature } from '../resources';\nimport {\n  EDDSAMethods,\n  ErrorNoInputToRecover,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCRecoveryOptions,\n  MPCTx,\n  RecoveryProviderError,\n  signRecoveryEddsaMPCv2,\n  TxIntentMismatchRecipientError,\n} from '@bitgo-beta/sdk-core';\nimport { TransferBuilder, V8TransferBuilder } from '../../src/lib';\nimport { testnetV8Material } from '../../src/resources';\nimport { MPSUtil } from '@bitgo-beta/sdk-lib-mpc';\n\ndescribe('Polyx:', function () {\n  let bitgo: TestBitGoAPI;\n  let baseCoin;\n\n  before(function () {\n    bitgo = TestBitGo.decorate(BitGoAPI, { env: 'mock' });\n    bitgo.safeRegister('polyx', Polyx.createInstance);\n    bitgo.safeRegister('tpolyx', Tpolyx.createInstance);\n    bitgo.initializeTestVars();\n    baseCoin = bitgo.coin('tpolyx') as Tpolyx;\n  });\n\n  describe('Address Format Constants', function () {\n    it('should have the correct address format constants', function () {\n      // Verify the constants are defined correctly\n      POLYX_ADDRESS_FORMAT.should.equal(12);\n      TPOLYX_ADDRESS_FORMAT.should.equal(42);\n    });\n  });\n\n  describe('Recover Transactions:', function () {\n    const sandBox = sinon.createSandbox();\n    const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';\n    const nonce = 0;\n    let accountInfoCB;\n    let headerInfoCB;\n    let getFeeCB;\n    let getMaterialCB;\n\n    beforeEach(function () {\n      accountInfoCB = sandBox.stub(Polyx.prototype, 'getAccountInfo' as keyof Polyx);\n      headerInfoCB = sandBox.stub(Polyx.prototype, 'getHeaderInfo' as keyof Polyx);\n      getFeeCB = sandBox.stub(Polyx.prototype, 'getFee' as keyof Polyx);\n      getMaterialCB = sandBox.stub(Polyx.prototype, 'getMaterial' as keyof Polyx);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tpolyx').network.type));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should generate unsigned sweep correctly', async function () {\n      accountInfoCB\n        .withArgs(testData.unsignedSweepUser.walletAddress)\n        .resolves({ nonce: 0, freeBalance: 100007000000 });\n      headerInfoCB.resolves({\n        headerNumber: testData.testnetBlock.blockNumber,\n        headerHash: testData.testnetBlock.hash,\n      });\n      getFeeCB.withArgs(recoveryDestination, testData.unsignedSweepUser.walletAddress, 100007000000).resolves(74401);\n\n      const commonKeyChain = testData.unsignedSweepUser.bitgoKey;\n\n      const unsigned = await baseCoin.recover({ bitgoKey: commonKeyChain, recoveryDestination });\n\n      unsigned.txRequests.should.not.be.undefined();\n      unsigned.txRequests.length.should.equal(1);\n      unsigned.txRequests[0].transactions.length.should.equal(1);\n      unsigned.txRequests[0].walletCoin.should.equal('tpolyx');\n      unsigned.txRequests[0].transactions[0].unsignedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.serializedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.scanIndex.should.equal(0);\n      unsigned.txRequests[0].transactions[0].unsignedTx.coin.should.equal('tpolyx');\n      unsigned.txRequests[0].transactions[0].unsignedTx.signableHex.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.derivationPath.should.equal('m/0');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs.length.should.equal(1);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].address.should.equal(\n        '5DnZQqbxtB3CWkLgfA6wpqdkCd9Bq7AX49RpLPJwW9mzoT7s'\n      );\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].valueString.should.equal('100006255990');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.inputs[0].value.should.equal(100006255990);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs.length.should.equal(1);\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].address.should.equal(\n        '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7'\n      );\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].valueString.should.equal('100006255990');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.outputs[0].coinName.should.equal('tpolyx');\n      unsigned.txRequests[0].transactions[0].unsignedTx.parsedTx.type.should.equal('');\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.fee.should.equal(0);\n      unsigned.txRequests[0].transactions[0].unsignedTx.feeInfo.feeString.should.equal('0');\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.firstValid.should.not.be.undefined();\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.maxDuration.should.equal(2400);\n      unsigned.txRequests[0].transactions[0].unsignedTx.coinSpecific.commonKeychain.should.equal(\n        '97d9da8bf544d07f3c7ae8ee06bb12a63f74478d0c461201ab94421a9c81d5b379553f0332daaa85cb8c65e1fe7e6907c62268c00812b08a4e1361178e304ddb'\n      );\n    });\n\n    it('should recover a tx for non-bitgo recoveries', async function () {\n      accountInfoCB.withArgs(testData.wrwUser.walletAddress).resolves({ nonce: 0, freeBalance: 100007000000 });\n      headerInfoCB.resolves({\n        headerNumber: testData.testnetBlock.blockNumber,\n        headerHash: testData.testnetBlock.hash,\n      });\n      getFeeCB.withArgs(recoveryDestination, testData.wrwUser.walletAddress, 100007000000).resolves(74401);\n\n      const res = await baseCoin.recover({\n        userKey: testData.wrwUser.userKey,\n        backupKey: testData.wrwUser.backupKey,\n        bitgoKey: testData.wrwUser.bitgoKey,\n        walletPassphrase: testData.wrwUser.walletPassphrase,\n        recoveryDestination: recoveryDestination,\n      });\n\n      res.should.not.be.empty();\n      res.should.hasOwnProperty('serializedTx');\n      res.should.hasOwnProperty('scanIndex');\n\n      const txBuilder = baseCoin.getBuilder().from(res.serializedTx);\n      txBuilder\n        .validity({\n          firstValid: testData.testnetBlock.blockNumber,\n          maxDuration: baseCoin.SWEEP_TXN_DURATION,\n        })\n        .referenceBlock(testData.testnetBlock.hash);\n\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.sender, testData.wrwUser.walletAddress);\n      should.deepEqual(txJson.blockNumber, testData.testnetBlock.blockNumber);\n      should.deepEqual(txJson.referenceBlock, testData.testnetBlock.hash);\n      should.deepEqual(txJson.genesisHash, genesisHash);\n      should.deepEqual(txJson.specVersion, specVersion);\n      should.deepEqual(txJson.nonce, nonce);\n      should.deepEqual(txJson.tip, 0);\n      should.deepEqual(txJson.transactionVersion, txVersion);\n      should.deepEqual(txJson.eraPeriod, baseCoin.SWEEP_TXN_DURATION);\n    });\n\n    it('should recover a txn for unsigned-sweep recoveries', async function () {\n      accountInfoCB\n        .withArgs(testData.unsignedSweepUser.walletAddress)\n        .resolves({ nonce: 0, freeBalance: 100007000000 });\n      headerInfoCB.resolves({\n        headerNumber: testData.testnetBlock.blockNumber,\n        headerHash: testData.testnetBlock.hash,\n      });\n      getFeeCB.withArgs(recoveryDestination, testData.unsignedSweepUser.walletAddress, 100007000000).resolves(74401);\n\n      const res = await baseCoin.recover({\n        bitgoKey: testData.unsignedSweepUser.bitgoKey,\n        recoveryDestination: recoveryDestination,\n      });\n\n      res.should.not.be.empty();\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('serializedTx');\n      res.txRequests[0].transactions[0].unsignedTx.should.hasOwnProperty('scanIndex');\n\n      const txBuilder = baseCoin.getBuilder().from(res.txRequests[0].transactions[0].unsignedTx.serializedTx);\n      txBuilder\n        .validity({\n          firstValid: testData.testnetBlock.blockNumber,\n          maxDuration: baseCoin.SWEEP_TXN_DURATION,\n        })\n        .referenceBlock(testData.testnetBlock.hash)\n        .sender({ address: testData.unsignedSweepUser.walletAddress });\n\n      const tx = await txBuilder.build();\n      const txJson = tx.toJson();\n      should.deepEqual(txJson.sender, testData.unsignedSweepUser.walletAddress);\n      should.deepEqual(txJson.blockNumber, testData.testnetBlock.blockNumber);\n      should.deepEqual(txJson.referenceBlock, testData.testnetBlock.hash);\n      should.deepEqual(txJson.genesisHash, genesisHash);\n      should.deepEqual(txJson.specVersion, specVersion);\n      should.deepEqual(txJson.nonce, 0);\n      should.deepEqual(txJson.tip, 0);\n      should.deepEqual(txJson.transactionVersion, txVersion);\n      should.deepEqual(txJson.eraPeriod, baseCoin.SWEEP_TXN_DURATION);\n    });\n\n    describe('MPCv2 signed recovery', function () {\n      const walletPassphrase = 'test-passphrase-mpcv2';\n      let mpcV2UserKey: string;\n      let mpcV2BackupKey: string;\n      let mpcV2CommonKeyChain: string;\n      let mpcV2RecoverParams: MPCRecoveryOptions;\n\n      before(async function () {\n        const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n        mpcV2CommonKeyChain = userDkg.getCommonKeychain();\n        mpcV2UserKey = await encrypt(walletPassphrase, userDkg.getReducedKeyShare().toString('base64'));\n        mpcV2BackupKey = await encrypt(walletPassphrase, backupDkg.getReducedKeyShare().toString('base64'));\n\n        mpcV2RecoverParams = {\n          userKey: mpcV2UserKey,\n          backupKey: mpcV2BackupKey,\n          bitgoKey: mpcV2CommonKeyChain,\n          recoveryDestination,\n          walletPassphrase,\n        };\n      });\n\n      beforeEach(function () {\n        // Use unrestricted resolves (not .withArgs) since the mismatched-bitgoKey test\n        // derives a different sender address than mpcV2WalletAddress.\n        accountInfoCB.resolves({ nonce: 0, freeBalance: 100007000000 });\n        headerInfoCB.resolves({\n          headerNumber: testData.testnetBlock.blockNumber,\n          headerHash: testData.testnetBlock.hash,\n        });\n        getFeeCB.resolves(74401);\n      });\n\n      it('should recover a tx using MPCv2 signing material', async function () {\n        const getTSSSignatureSpy = sandBox.spy(EDDSAMethods, 'getTSSSignature');\n        const addSignatureSpy = sandBox.spy(TransferBuilder.prototype, 'addSignature');\n\n        const result = (await baseCoin.recover(mpcV2RecoverParams)) as MPCTx;\n\n        result.should.not.be.empty();\n        result.should.hasOwnProperty('serializedTx');\n        result.should.hasOwnProperty('scanIndex');\n        should.equal(result.scanIndex, 0);\n        (result.serializedTx as string).should.be.a.String().and.not.be.empty();\n        sandBox.assert.notCalled(getTSSSignatureSpy);\n\n        sandBox.assert.calledOnce(addSignatureSpy);\n        const signature: Buffer = addSignatureSpy.firstCall.args[1];\n        // constructSignedPayload prepends the 0x00 Ed25519 discriminant internally;\n        // recover() must pass the raw 64-byte signature unchanged.\n        signature.length.should.equal(64);\n      });\n\n      it('should produce a cryptographically valid Ed25519 signature', async function () {\n        const addSignatureSpy = sandBox.spy(TransferBuilder.prototype, 'addSignature');\n        const signRecoverySpy = sandBox.spy(\n          baseCoin as unknown as { signSubstrateMpcV2Recovery: unknown },\n          'signSubstrateMpcV2Recovery'\n        );\n\n        await baseCoin.recover(mpcV2RecoverParams);\n\n        // 65-byte sig: 0x00 discriminant + 64-byte Ed25519 sig; signatureVerify handles the prefix.\n        const signature: Buffer = addSignatureSpy.firstCall.args[1];\n\n        // Capture the exact bytes signed by the DSG protocol inside signSubstrateMpcV2Recovery.\n        const signablePayload: Buffer = (signRecoverySpy.firstCall.args[0] as { message: Buffer }).message;\n\n        const MPC = await EDDSAMethods.getInitializedMpcInstance();\n        const accountId = MPC.deriveUnhardened(mpcV2CommonKeyChain, 'm/0').slice(0, 64);\n\n        const senderAddr = baseCoin.getAddressFromPublicKey(accountId);\n        const isValid = utils.verifySignature(\n          `0x${signablePayload.toString('hex')}`,\n          `0x${signature.toString('hex')}`,\n          senderAddr\n        );\n        isValid.should.be.true();\n      });\n\n      it('should use MPCv1 path when signing material is MPCv1 format', async function () {\n        const userPrv = JSON.stringify({ uShare: { seed: 'aa' }, bitgoYShare: { u: 'bb' }, backupYShare: { u: 'cc' } });\n        sandBox\n          .stub(baseCoin as unknown as { getEddsaSigningMaterial: unknown }, 'getEddsaSigningMaterial')\n          .resolves({ version: 'v1', userPrv });\n\n        const getTSSSignatureStub = sandBox\n          .stub(EDDSAMethods, 'getTSSSignature')\n          .resolves(\n            Buffer.from(\n              '1baafa0d62174bf0c78f3256318613ffc44b6dd54ab1a63c2185232f92ede9da' +\n                'e1b2818dbeb52a8215fd56f5a5f2a9f94c079ce89e4dc3b1ce6ed6e84ce71857',\n              'hex'\n            )\n          );\n\n        sandBox\n          .stub(bitgo, 'decrypt')\n          .withArgs(sinon.match({ input: mpcV2BackupKey.replace(/\\s/g, '') }))\n          .resolves(JSON.stringify({ bShare: {}, yShares: {} }));\n\n        const result = (await baseCoin.recover(mpcV2RecoverParams)) as MPCTx;\n\n        result.should.not.be.empty();\n        result.should.hasOwnProperty('serializedTx');\n        result.should.hasOwnProperty('scanIndex');\n        should.equal(result.scanIndex, 0);\n        (result.serializedTx as string).should.be.a.String().and.not.be.empty();\n        sandBox.assert.calledOnce(getTSSSignatureStub);\n      });\n\n      it('should throw a descriptive error when user keychain decryption fails on the MPCv1 path', async function () {\n        sandBox.stub(bitgo, 'decrypt').rejects(new Error('password error'));\n\n        await baseCoin.recover(mpcV2RecoverParams).should.be.rejectedWith(/Error decrypting user keychain/);\n      });\n\n      it('should throw when commonKeyChain from MPCv2 keycard does not match bitgoKey', async function () {\n        const mismatchedBitgoKey = mpcV2CommonKeyChain.slice(0, -8) + '00000000';\n        const mismatchedParams = {\n          ...mpcV2RecoverParams,\n          bitgoKey: mismatchedBitgoKey,\n        };\n\n        await baseCoin\n          .recover(mismatchedParams)\n          .should.be.rejectedWith('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');\n      });\n\n      it('should throw missing userKey when backupKey and walletPassphrase are present but userKey is not', async function () {\n        const paramsWithoutUserKey = { ...mpcV2RecoverParams, userKey: undefined };\n        await baseCoin.recover(paramsWithoutUserKey).should.be.rejectedWith('missing userKey');\n      });\n\n      it('should throw missing backupKey when userKey and walletPassphrase are present but backupKey is not', async function () {\n        const paramsWithoutBackupKey = { ...mpcV2RecoverParams, backupKey: undefined };\n        await baseCoin.recover(paramsWithoutBackupKey).should.be.rejectedWith('missing backupKey');\n      });\n\n      it('should throw missing wallet passphrase when userKey and backupKey are present but walletPassphrase is not', async function () {\n        const paramsWithoutPassphrase = { ...mpcV2RecoverParams, walletPassphrase: undefined };\n        await baseCoin.recover(paramsWithoutPassphrase).should.be.rejectedWith('missing wallet passphrase');\n      });\n\n      it('should pass the raw 64-byte signature to addSignature on MPCv2 path', async function () {\n        // Regression: previously wrapped rawSig with a manual Ed25519 discriminant (0x00)\n        // before addSignature. constructSignedPayload already prepends that discriminant,\n        // so wrapping here caused a double prefix that shifted the on-wire signature by\n        // one byte, dropping the last byte of sigma and producing\n        // `1010: Bad signature` on-chain.\n        const rawSig = Buffer.alloc(64, 0xab);\n        sandBox\n          .stub(baseCoin as unknown as { signSubstrateMpcV2Recovery: unknown }, 'signSubstrateMpcV2Recovery')\n          .resolves(rawSig);\n        const addSignatureSpy = sandBox.spy(TransferBuilder.prototype, 'addSignature');\n\n        await baseCoin.recover(mpcV2RecoverParams);\n\n        sandBox.assert.calledOnce(addSignatureSpy);\n        const sig: Buffer = addSignatureSpy.firstCall.args[1];\n        sig.length.should.equal(64);\n        sig.should.deepEqual(rawSig);\n      });\n    });\n  });\n\n  describe('Recover Transaction Failures:', function () {\n    const sandBox = sinon.createSandbox();\n    const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';\n\n    beforeEach(function () {\n      sandBox.stub(Polyx.prototype, 'getAccountInfo' as keyof Polyx).resolves({ nonce: 0, freeBalance: 0 });\n      sandBox.stub(Polyx.prototype, 'getFee' as keyof Polyx).resolves(74401);\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    it('should fail to recover due to not finding an address with funds', async function () {\n      await baseCoin\n        .recover({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          walletPassphrase: testData.wrwUser.walletPassphrase,\n          recoveryDestination,\n        })\n        .should.rejectedWith(ErrorNoInputToRecover);\n    });\n\n    it('should throw RecoveryProviderError when account info query fails', async function () {\n      (Polyx.prototype as unknown as { getAccountInfo: sinon.SinonStub }).getAccountInfo.rejects(\n        new Error('network failure')\n      );\n      await baseCoin\n        .recover({\n          userKey: testData.wrwUser.userKey,\n          backupKey: testData.wrwUser.backupKey,\n          bitgoKey: testData.wrwUser.bitgoKey,\n          walletPassphrase: testData.wrwUser.walletPassphrase,\n          recoveryDestination,\n        })\n        .should.be.rejectedWith(RecoveryProviderError);\n    });\n  });\n\n  describe('Token Enablement:', function () {\n    it('should have correct token enablement config', function () {\n      const config = baseCoin.getTokenEnablementConfig();\n      should.exist(config);\n      config.requiresTokenEnablement.should.equal(true);\n      config.supportsMultipleTokenEnablements.should.equal(false);\n    });\n\n    it('should validate wallet type for token enablement', function () {\n      const config = baseCoin.getTokenEnablementConfig();\n      (() => config.validateWallet('custodial')).should.not.throw();\n      (() => config.validateWallet('hot')).should.throw(\n        /Token enablement for Polymesh \\(polyx\\) is only supported for custodial wallets/\n      );\n      (() => config.validateWallet('cold')).should.throw(\n        /Token enablement for Polymesh \\(polyx\\) is only supported for custodial wallets/\n      );\n    });\n  });\n\n  describe('verifyTransaction', function () {\n    const transferTo = '5F8jxKE81GhFrphyfMFr5UjeAz5wS4AaZFmeFPnf8wTetD72';\n    const transferAmount = '2000000000';\n    const wrongAddress = '5GhbC6n2pUFrX98DwyPit67fB5AwQvVCwZ4j2HKA7a4dUK4y';\n\n    describe('transfer transaction', function () {\n      it('should return true when address and amount match', async function () {\n        const result = await baseCoin.verifyTransaction({\n          txPrebuild: { txHex: rawTx.transfer.signed },\n          txParams: { recipients: [{ address: transferTo, amount: transferAmount }] },\n        });\n        result.should.be.true();\n      });\n\n      it('should throw TxIntentMismatchRecipientError for address mismatch', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: { txHex: rawTx.transfer.signed },\n            txParams: { recipients: [{ address: wrongAddress, amount: transferAmount }] },\n          })\n          .should.be.rejectedWith(TxIntentMismatchRecipientError);\n      });\n\n      it('should throw TxIntentMismatchRecipientError for amount mismatch', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: { txHex: rawTx.transfer.signed },\n            txParams: { recipients: [{ address: transferTo, amount: '1' }] },\n          })\n          .should.be.rejectedWith(TxIntentMismatchRecipientError);\n      });\n    });\n\n    describe('guard cases', function () {\n      it('should throw when txHex is missing', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: {},\n            txParams: { recipients: [{ address: transferTo, amount: transferAmount }] },\n          })\n          .should.be.rejectedWith('missing txHex in txPrebuild');\n      });\n\n      it('should throw when recipients has more than 1 entry', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: { txHex: rawTx.transfer.signed },\n            txParams: {\n              recipients: [\n                { address: transferTo, amount: transferAmount },\n                { address: wrongAddress, amount: transferAmount },\n              ],\n            },\n          })\n          .should.be.rejectedWith(/support sending to more than 1 destination address/);\n      });\n\n      it('should throw when recipients is an empty array', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: { txHex: rawTx.transfer.signed },\n            txParams: { recipients: [] },\n          })\n          .should.be.rejectedWith('missing recipients in txParams');\n      });\n    });\n\n    describe('token enablement (preApproveAsset) transaction', function () {\n      it('should return true for enabletoken type with recipients (wallet root address)', async function () {\n        // buildTokenEnablements sets recipients[0].address = wallet rootAddress and type = 'enabletoken'.\n        // verifyTransaction must short-circuit before the _to check since preApproveAsset has no destination.\n        const walletAddress = '5F8jxKE81GhFrphyfMFr5UjeAz5wS4AaZFmeFPnf8wTetD72';\n        const result = await baseCoin.verifyTransaction({\n          txPrebuild: { txHex: rawTx.preApproveAsset.signed },\n          txParams: {\n            type: 'enabletoken',\n            recipients: [{ address: walletAddress, amount: '0', tokenName: 'tpolyx:sometoken' }],\n          },\n        });\n        result.should.be.true();\n      });\n\n      it('should return true for enabletoken type with no recipients', async function () {\n        const result = await baseCoin.verifyTransaction({\n          txPrebuild: { txHex: rawTx.preApproveAsset.signed },\n          txParams: { type: 'enabletoken' },\n        });\n        result.should.be.true();\n      });\n    });\n\n    describe('v8 transfer with coinSpecific.material', function () {\n      const v8Amount = '1000000';\n      const v8Receiver = accounts.account2;\n      const v8Sender = accounts.account1;\n      let v8SignedTxHex: string;\n\n      before(async function () {\n        // Build a signed v8 transfer tx using testnetV8Material.\n        // The server embeds this material in coinSpecific during prebuild so that\n        // verifyTransaction can decode txHex built against a chain spec newer than\n        // the SDK's hardcoded v7 material (CECHO-1471).\n        const builder = new V8TransferBuilder(coins.get('tpolyx'))\n          .amount(v8Amount)\n          .to({ address: v8Receiver.address })\n          .sender({ address: v8Sender.address })\n          .memo('0')\n          .validity({ firstValid: 3933, maxDuration: 64 })\n          .referenceBlock('0x149799bc9602cb5cf201f3425fb8d253b2d4e61fc119dcab3249f307f594754d')\n          .sequenceId({ name: 'Nonce', keyword: 'nonce', value: 1 })\n          .fee({ amount: 0, type: 'tip' });\n        builder.addSignature({ pub: v8Sender.publicKey }, Buffer.from(mockTssSignature, 'hex'));\n        const tx = await builder.build();\n        v8SignedTxHex = tx.toBroadcastFormat();\n      });\n\n      it('verifies a v8 transfer when coinSpecific.material is provided', async function () {\n        const result = await baseCoin.verifyTransaction({\n          txPrebuild: {\n            txHex: v8SignedTxHex,\n            coinSpecific: { material: testnetV8Material },\n          },\n          txParams: { recipients: [{ address: v8Receiver.address, amount: v8Amount }] },\n        });\n        result.should.be.true();\n      });\n\n      it('throws TxIntentMismatchRecipientError for address mismatch on v8 transfer', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: {\n              txHex: v8SignedTxHex,\n              coinSpecific: { material: testnetV8Material },\n            },\n            txParams: { recipients: [{ address: wrongAddress, amount: v8Amount }] },\n          })\n          .should.be.rejectedWith(TxIntentMismatchRecipientError);\n      });\n\n      it('throws TxIntentMismatchRecipientError for amount mismatch on v8 transfer', async function () {\n        await baseCoin\n          .verifyTransaction({\n            txPrebuild: {\n              txHex: v8SignedTxHex,\n              coinSpecific: { material: testnetV8Material },\n            },\n            txParams: { recipients: [{ address: v8Receiver.address, amount: '1' }] },\n          })\n          .should.be.rejectedWith(TxIntentMismatchRecipientError);\n      });\n    });\n  });\n\n  describe('createBroadcastableSweepTransaction (MPCv2):', () => {\n    const sandBox = sinon.createSandbox();\n    let userKeyShare: Buffer;\n    let backupKeyShare: Buffer;\n    let commonKeychain: string;\n    let mpcv2SweepTxRequest: any;\n    let mpcv2SignatureHex: string;\n\n    before(async function () {\n      const [userDkg, backupDkg] = await MPSUtil.generateEdDsaDKGKeyShares();\n      commonKeychain = userDkg.getCommonKeychain();\n      userKeyShare = userDkg.getKeyShare();\n      backupKeyShare = backupDkg.getKeyShare();\n\n      const recoveryDestination = '5H56f31hSYGCRV3URjQHv2Cc4ZSkJNHTM8MKGtkkV6hzCqN7';\n      const mpc = await EDDSAMethods.getInitializedMpcInstance();\n      const walletAddress = baseCoin.getAddressFromPublicKey(mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64));\n      const accountInfoCB = sandBox.stub(Polyx.prototype, 'getAccountInfo' as keyof Polyx);\n      accountInfoCB.withArgs(walletAddress).resolves({ nonce: 0, freeBalance: 100007000000 });\n      const headerInfoCB = sandBox.stub(Polyx.prototype, 'getHeaderInfo' as keyof Polyx);\n      headerInfoCB.resolves({\n        headerNumber: testData.testnetBlock.blockNumber,\n        headerHash: testData.testnetBlock.hash,\n      });\n      const getFeeCB = sandBox.stub(Polyx.prototype, 'getFee' as keyof Polyx);\n      getFeeCB.withArgs(recoveryDestination, walletAddress, 100007000000).resolves(74401);\n      const getMaterialCB = sandBox.stub(Polyx.prototype, 'getMaterial' as keyof Polyx);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tpolyx').network.type));\n\n      // no walletPassphrase -> unsigned sweep path returns MPCSweepTxs\n      const sweep = (await baseCoin.recover({\n        bitgoKey: commonKeychain,\n        recoveryDestination,\n      })) as MPCSweepTxs;\n      sandBox.restore();\n\n      mpcv2SweepTxRequest = sweep.txRequests[0];\n      const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;\n      const signature = await signRecoveryEddsaMPCv2(\n        Buffer.from(unsignedTx.signableHex, 'hex'),\n        unsignedTx.derivationPath,\n        userKeyShare,\n        backupKeyShare,\n        commonKeychain\n      );\n      mpcv2SignatureHex = signature.toString('hex');\n    });\n\n    // createBroadcastableSweepTransaction calls getMaterial() to re-encode the signed\n    // transaction; stub it with the same testnet material the sweep was built with.\n    beforeEach(function () {\n      const getMaterialCB = sandBox.stub(Polyx.prototype, 'getMaterial' as keyof Polyx);\n      getMaterialCB.resolves(utils.getMaterial(coins.get('tpolyx').network.type));\n    });\n\n    afterEach(function () {\n      sandBox.restore();\n    });\n\n    function buildParams(ovc: any): MPCSweepRecoveryOptions {\n      return {\n        signatureShares: [\n          {\n            txRequest: mpcv2SweepTxRequest,\n            tssVersion: '0.0.1',\n            ovc: [ovc],\n          },\n        ],\n      } as MPCSweepRecoveryOptions;\n    }\n\n    it('should take MPCv2 OVC output and generate a signed sweep transaction', async function () {\n      const params = buildParams({ eddsaMpcv2Signature: mpcv2SignatureHex });\n      const recoveryTxn = await baseCoin.createBroadcastableSweepTransaction(params);\n\n      recoveryTxn.transactions[0].serializedTx.should.not.equal(\n        mpcv2SweepTxRequest.transactions[0].unsignedTx.serializedTx\n      );\n      recoveryTxn.transactions[0].serializedTx.should.not.be.empty();\n      (recoveryTxn.transactions[0].scanIndex ?? 0).should.equal(0);\n      (recoveryTxn.lastScanIndex ?? 0).should.equal(0);\n    });\n\n    it('should reject a tampered MPCv2 signature', async function () {\n      const unsignedTx = mpcv2SweepTxRequest.transactions[0].unsignedTx;\n      const tamperedMessage = Buffer.concat([Buffer.from(unsignedTx.signableHex, 'hex'), Buffer.from('00', 'hex')]);\n      const tamperedSignature = await signRecoveryEddsaMPCv2(\n        tamperedMessage,\n        unsignedTx.derivationPath,\n        userKeyShare,\n        backupKeyShare,\n        commonKeychain\n      );\n\n      await baseCoin\n        .createBroadcastableSweepTransaction(buildParams({ eddsaMpcv2Signature: tamperedSignature.toString('hex') }))\n        .should.be.rejectedWith('Invalid signature');\n    });\n\n    it('should throw when MPCv2 OVC is missing signature(s)', async function () {\n      await baseCoin\n        .createBroadcastableSweepTransaction(buildParams({}))\n        .should.be.rejectedWith('Missing signature(s)');\n    });\n\n    it('should route MPCv1-shaped ovc to the MPCv1 verify branch and reject an invalid signature', async function () {\n      const mpc = await EDDSAMethods.getInitializedMpcInstance();\n      const derivedPubKey = mpc.deriveUnhardened(commonKeychain, 'm/0').slice(0, 64);\n      await baseCoin\n        .createBroadcastableSweepTransaction(\n          buildParams({\n            eddsaSignature: { R: '00'.repeat(32), sigma: '00'.repeat(32), y: derivedPubKey },\n          })\n        )\n        .should.be.rejectedWith('Invalid signature');\n    });\n  });\n});\n"]}