@bitgo-beta/sdk-coin-dot 2.2.8-beta.21 → 2.2.8-beta.2100

package/dist/cjs/src/dot.js

@@ -0,0 +1,688 @@
+"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 });
+exports.Dot = exports.DEFAULT_SCAN_FACTOR = void 0;
+const assert_1 = __importDefault(require("assert"));
+const _ = __importStar(require("lodash"));
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const lib_1 = require("./lib");
+require("@polkadot/api-augment");
+const api_1 = require("@polkadot/api");
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+exports.DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds
+const dotUtils = lib_1.Utils.default;
+function isEddsaSigningMaterial(value) {
+    if (typeof value !== 'object' || value === null) {
+        return false;
+    }
+    if (!('version' in value)) {
+        return false;
+    }
+    if (value.version === 'v1') {
+        return 'userPrv' in value && typeof value.userPrv === 'string';
+    }
+    if (value.version === 'v2') {
+        return 'encryptedUserKey' in value && typeof value.encryptedUserKey === 'string';
+    }
+    return false;
+}
+class Dot extends sdk_core_1.BaseCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo);
+        this.MAX_VALIDITY_DURATION = 2400;
+        this.SWEEP_TXN_DURATION = 64;
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Dot(bitgo, staticsCoin);
+    }
+    getChain() {
+        return 'dot';
+    }
+    getBaseChain() {
+        return 'dot';
+    }
+    getFamily() {
+        return 'dot';
+    }
+    getFullName() {
+        return 'Polkadot';
+    }
+    getBaseFactor() {
+        return Math.pow(10, this._staticsCoin.decimalPlaces);
+    }
+    /**
+     * Flag for sending value of 0
+     * @returns {boolean} True if okay to send 0 value, false otherwise
+     */
+    valuelessTransferAllowed() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsTss() {
+        return true;
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.tss;
+    }
+    getMPCAlgorithm() {
+        return 'eddsa';
+    }
+    allowsAccountConsolidations() {
+        return true;
+    }
+    /**
+     * Generate ed25519 key pair
+     *
+     * @param seed
+     * @returns {Object} object with generated pub, prv
+     */
+    generateKeyPair(seed) {
+        const keyPair = seed ? dotUtils.keyPairFromSeed(new Uint8Array(seed)) : new lib_1.KeyPair();
+        const keys = keyPair.getKeys();
+        if (!keys.prv) {
+            throw new Error('Missing prv in key generation.');
+        }
+        return {
+            pub: keys.pub,
+            prv: keys.prv,
+        };
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin.
+     *
+     * @param {String} pub the pub to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidPub(pub) {
+        return dotUtils.isValidPublicKey(pub);
+    }
+    /**
+     * Return boolean indicating whether the supplied private key is a valid dot private key
+     *
+     * @param {String} prv the prv to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidPrv(prv) {
+        return dotUtils.isValidPrivateKey(prv);
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin
+     *
+     * @param {String} address the pub to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidAddress(address) {
+        return dotUtils.isValidAddress(address);
+    }
+    /**
+     * Sign message with private key
+     *
+     * @param key
+     * @param message
+     * @return {Buffer} A signature over the given message using the given key
+     */
+    async signMessage(key, message) {
+        const msg = Buffer.isBuffer(message) ? message.toString('utf8') : message;
+        // reconstitute keys and sign
+        return Buffer.from(new lib_1.KeyPair({ prv: key.prv }).signMessage(msg));
+    }
+    /**
+     * Explain/parse transaction
+     * @param unsignedTransaction
+     */
+    async explainTransaction(unsignedTransaction) {
+        let outputAmount = 0;
+        unsignedTransaction.parsedTx.outputs.forEach((o) => {
+            outputAmount += parseInt(o.valueString, 10);
+        });
+        const explanationResult = {
+            displayOrder: [
+                'outputAmount',
+                'changeAmount',
+                'outputs',
+                'changeOutputs',
+                'fee',
+                'type',
+                'sequenceId',
+                'id',
+                'blockNumber',
+            ],
+            sequenceId: unsignedTransaction.parsedTx.sequenceId,
+            fee: unsignedTransaction.feeInfo?.feeString,
+            id: unsignedTransaction.parsedTx.id,
+            type: unsignedTransaction.parsedTx.type,
+            outputs: unsignedTransaction.parsedTx.outputs,
+            blockNumber: unsignedTransaction.coinSpecific?.blockNumber,
+            outputAmount: outputAmount,
+            changeOutputs: [],
+            changeAmount: '0',
+        };
+        return explanationResult;
+    }
+    verifySignTransactionParams(params) {
+        const prv = params.prv;
+        const txHex = params.txPrebuild.txHex;
+        if (!txHex) {
+            throw new Error('missing txPrebuild parameter');
+        }
+        if (!_.isString(txHex)) {
+            throw new Error(`txPrebuild must be an object, got type ${typeof txHex}`);
+        }
+        if (!prv) {
+            throw new Error('missing prv parameter to sign transaction');
+        }
+        if (!_.isString(prv)) {
+            throw new Error(`prv must be a string, got type ${typeof prv}`);
+        }
+        if (!_.has(params, 'pubs')) {
+            throw new Error('missing public key parameter to sign transaction');
+        }
+        return { txHex, prv };
+    }
+    /**
+     * Assemble keychain and half-sign prebuilt transaction
+     *
+     * @param params
+     * @param params.txPrebuild {TransactionPrebuild} prebuild object returned by platform
+     * @param params.prv {String} user prv
+     * @returns {Promise<SignedTransaction>}
+     */
+    async signTransaction(params) {
+        const { txHex, prv } = this.verifySignTransactionParams(params);
+        const factory = this.getBuilder();
+        const txBuilder = factory.from(txHex);
+        const keyPair = new lib_1.KeyPair({ prv: prv });
+        const { referenceBlock, blockNumber, transactionVersion, sender } = params.txPrebuild.transaction;
+        txBuilder
+            .validity({ firstValid: blockNumber, maxDuration: this.MAX_VALIDITY_DURATION })
+            .referenceBlock(referenceBlock)
+            .version(transactionVersion)
+            .sender({ address: sender })
+            .sign({ key: keyPair.getKeys().prv });
+        const transaction = await txBuilder.build();
+        if (!transaction) {
+            throw new Error('Invalid transaction');
+        }
+        const signedTxHex = transaction.toBroadcastFormat();
+        return { txHex: signedTxHex };
+    }
+    async getInitializedNodeAPI() {
+        if (!Dot.nodeApiInitialized) {
+            const wsProvider = new api_1.WsProvider(sdk_core_1.Environments[this.bitgo.getEnv()].dotNodeUrls);
+            Dot.API = await api_1.ApiPromise.create({ provider: wsProvider });
+            Dot.nodeApiInitialized = true;
+        }
+        return Dot.API;
+    }
+    async getAccountInfo(walletAddr) {
+        const api = await this.getInitializedNodeAPI();
+        const { nonce, data: balance } = await api.query.system.account(walletAddr);
+        return { nonce: nonce.toNumber(), freeBalance: balance.free.toNumber() };
+    }
+    async getHeaderInfo() {
+        const api = await this.getInitializedNodeAPI();
+        const finalizedHash = await api.rpc.chain.getFinalizedHead();
+        const { number, hash } = await api.rpc.chain.getHeader(finalizedHash);
+        return { headerNumber: number.toNumber(), headerHash: hash.toString() };
+    }
+    /**
+     *
+     * Estimate the fee of the transaction
+     *
+     * @param {string} destAddr destination wallet address
+     * @param {string} srcAddr source wallet address
+     * @param {string} amount amount to transfer
+     * @returns {number} the estimated fee the transaction will cost
+     *
+     * @see https://polkadot.js.org/docs/api/cookbook/tx#how-do-i-estimate-the-transaction-fees
+     */
+    async getFee(destAddr, srcAddr, amount) {
+        const api = await this.getInitializedNodeAPI();
+        const info = await api.tx.balances.transferAllowDeath(destAddr, amount).paymentInfo(srcAddr);
+        return info.partialFee.toNumber();
+    }
+    async getMaterial() {
+        const api = await this.getInitializedNodeAPI();
+        return {
+            genesisHash: api.genesisHash.toString(),
+            chainName: api.runtimeChain.toString(),
+            specName: api.runtimeVersion.specName.toString(),
+            specVersion: api.runtimeVersion.specVersion.toNumber(),
+            txVersion: api.runtimeVersion.transactionVersion.toNumber(),
+            metadata: api.runtimeMetadata.toHex(),
+        };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param {MPCRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     * @param {EddsaSigningMaterial} [precomputedMaterial] optional decrypted
+     * material from recoverConsolidations; non-matching values are ignored
+     *
+     * @returns {MPCTx} the serialized transaction hex string and index
+     * of the address being swept
+     */
+    async recover(params, precomputedMaterial) {
+        if (!params.bitgoKey) {
+            throw new Error('missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const index = params.index || 0;
+        const currPath = params.seed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.seed) + `/${index}` : `m/${index}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+        const senderAddr = this.getAddressFromPublicKey(accountId);
+        let accountInfo;
+        let partialFee;
+        try {
+            accountInfo = await this.getAccountInfo(senderAddr);
+            partialFee = await this.getFee(params.recoveryDestination, senderAddr, accountInfo.freeBalance);
+        }
+        catch (e) {
+            throw new sdk_core_1.RecoveryProviderError(`Failed to query account balance or fee for ${senderAddr}`, e);
+        }
+        const { nonce, freeBalance } = accountInfo;
+        const value = new bignumber_js_1.default(freeBalance).minus(new bignumber_js_1.default(partialFee));
+        if (value.isLessThanOrEqualTo(0)) {
+            throw new sdk_core_1.ErrorNoInputToRecover('Did not find address with funds to recover');
+        }
+        // first build the unsigned txn
+        let headerInfo;
+        let material;
+        try {
+            headerInfo = await this.getHeaderInfo();
+            material = await this.getMaterial();
+        }
+        catch (e) {
+            throw new sdk_core_1.RecoveryProviderError('Failed to query chain header or material', e);
+        }
+        const { headerNumber, headerHash } = headerInfo;
+        const validityWindow = { firstValid: headerNumber, maxDuration: this.MAX_VALIDITY_DURATION };
+        const txnBuilder = this.getBuilder().getTransferBuilder().material(material);
+        txnBuilder
+            .sweep(false)
+            .to({ address: params.recoveryDestination })
+            .sender({ address: senderAddr })
+            .validity(validityWindow)
+            .referenceBlock(headerHash)
+            .sequenceId({ name: 'Nonce', keyword: 'nonce', value: nonce })
+            .fee({ amount: 0, type: 'tip' });
+        const unsignedTransaction = (await txnBuilder.build());
+        let serializedTx = unsignedTransaction.toBroadcastFormat();
+        if (!isUnsignedSweep) {
+            (0, assert_1.default)(params.userKey, 'missing userKey');
+            (0, assert_1.default)(params.backupKey, 'missing backupKey');
+            (0, assert_1.default)(params.walletPassphrase, 'missing wallet passphrase');
+            const signingMaterial = isEddsaSigningMaterial(precomputedMaterial)
+                ? precomputedMaterial
+                : await this.getEddsaSigningMaterial(params.userKey, params.walletPassphrase);
+            await this.addRecoverySignature(signingMaterial, params.backupKey.replace(/\s/g, ''), params.walletPassphrase, txnBuilder, accountId, unsignedTransaction, currPath, bitgoKey);
+            const signedTransaction = await txnBuilder.build();
+            serializedTx = signedTransaction.toBroadcastFormat();
+        }
+        else {
+            const value = new bignumber_js_1.default(freeBalance);
+            const walletCoin = this.getChain();
+            const inputs = [
+                {
+                    address: unsignedTransaction.inputs[0].address,
+                    valueString: value.toString(),
+                    value: value.toNumber(),
+                },
+            ];
+            const outputs = [
+                {
+                    address: unsignedTransaction.outputs[0].address,
+                    valueString: value.toString(),
+                    coinName: walletCoin,
+                },
+            ];
+            const spendAmount = value.toString();
+            const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+            const feeInfo = { fee: 0, feeString: '0' };
+            const transaction = {
+                serializedTx: serializedTx,
+                scanIndex: index,
+                coin: walletCoin,
+                signableHex: unsignedTransaction.signablePayload.toString('hex'),
+                derivationPath: currPath,
+                parsedTx: parsedTx,
+                feeInfo: feeInfo,
+                coinSpecific: { ...validityWindow, commonKeychain: bitgoKey },
+            };
+            const unsignedTx = { unsignedTx: transaction, signatureShares: [] };
+            const transactions = [unsignedTx];
+            const txRequest = {
+                transactions: transactions,
+                walletCoin: walletCoin,
+            };
+            const txRequests = { txRequests: [txRequest] };
+            return txRequests;
+        }
+        const transaction = { serializedTx: serializedTx, scanIndex: index };
+        return transaction;
+    }
+    /**
+     * Builds native DOT recoveries of receive addresses in batch without BitGo.
+     * Funds will be recovered to base address first. You need to initiate another sweep txn after that.
+     *
+     * @param {MPCConsolidationRecoveryOptions} params - options for consolidation recovery.
+     * @param {string} [params.startingScanIndex] - receive address index to start scanning from. default to 1 (inclusive).
+     * @param {string} [params.endingScanIndex] - receive address index to end scanning at. default to startingScanIndex + 20 (exclusive).
+     */
+    async recoverConsolidations(params) {
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const startIdx = params.startingScanIndex || 1;
+        const endIdx = params.endingScanIndex || startIdx + exports.DEFAULT_SCAN_FACTOR;
+        if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * exports.DEFAULT_SCAN_FACTOR) {
+            throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const baseIndex = 0;
+        const basePath = params.seed ? (0, sdk_lib_mpc_1.getDerivationPath)(params.seed) + `/${baseIndex}` : `m/${baseIndex}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, basePath).slice(0, 64);
+        const baseAddress = this.getAddressFromPublicKey(accountId);
+        // Detect signing material once to avoid re-decrypting the keycard on every loop iteration.
+        const signingMaterial = params.walletPassphrase && params.userKey
+            ? await this.getEddsaSigningMaterial(params.userKey.replace(/\s/g, ''), params.walletPassphrase)
+            : undefined;
+        const consolidationTransactions = [];
+        let lastScanIndex = startIdx;
+        for (let i = startIdx; i < endIdx; i++) {
+            const recoverParams = {
+                userKey: params.userKey,
+                backupKey: params.backupKey,
+                bitgoKey: params.bitgoKey,
+                walletPassphrase: params.walletPassphrase,
+                recoveryDestination: baseAddress,
+                seed: params.seed,
+                index: i,
+            };
+            let recoveryTransaction;
+            try {
+                recoveryTransaction = await this.recover(recoverParams, signingMaterial);
+            }
+            catch (e) {
+                if (e instanceof sdk_core_1.ErrorNoInputToRecover) {
+                    lastScanIndex = i;
+                    continue;
+                }
+                throw e;
+            }
+            if (isUnsignedSweep) {
+                consolidationTransactions.push(recoveryTransaction.txRequests[0]);
+            }
+            else {
+                consolidationTransactions.push(recoveryTransaction);
+            }
+            lastScanIndex = i;
+        }
+        if (consolidationTransactions.length == 0) {
+            throw new sdk_core_1.ErrorNoInputToRecover('Did not find an address with funds to recover');
+        }
+        if (isUnsignedSweep) {
+            // lastScanIndex will be used to inform user the last address index scanned for available funds (so they can
+            // appropriately adjust the scan range on the next iteration of consolidation recoveries). In the case of unsigned
+            // sweep consolidations, this lastScanIndex will be provided in the coinSpecific of the last txn made.
+            const lastTransactionCoinSpecific = {
+                firstValid: consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific
+                    .firstValid,
+                maxDuration: consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific
+                    .maxDuration,
+                commonKeychain: consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific
+                    .commonKeychain,
+                lastScanIndex: lastScanIndex,
+            };
+            consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific =
+                lastTransactionCoinSpecific;
+            const consolidationSweepTransactions = { txRequests: consolidationTransactions };
+            return consolidationSweepTransactions;
+        }
+        return { transactions: consolidationTransactions, lastScanIndex };
+    }
+    /** inherited doc */
+    async createBroadcastableSweepTransaction(params) {
+        const req = params.signatureShares;
+        const broadcastableTransactions = [];
+        let lastScanIndex = 0;
+        for (let i = 0; i < req.length; i++) {
+            const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+            const transaction = req[i].txRequest.transactions[0].unsignedTx;
+            const ovc = req[i].ovc?.[0];
+            const mpcv2SignatureHex = ovc?.eddsaMpcv2Signature;
+            if (!ovc || (!mpcv2SignatureHex && !ovc.eddsaSignature)) {
+                throw new Error('Missing signature(s)');
+            }
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const messageBuffer = Buffer.from(transaction.signableHex, 'hex');
+            if (!transaction.coinSpecific ||
+                !transaction.coinSpecific?.firstValid ||
+                !transaction.coinSpecific?.maxDuration) {
+                throw new Error('missing validity window');
+            }
+            const validityWindow = {
+                firstValid: transaction.coinSpecific?.firstValid,
+                maxDuration: transaction.coinSpecific?.maxDuration,
+            };
+            const material = await this.getMaterial();
+            if (!transaction.coinSpecific?.commonKeychain) {
+                throw new Error('Missing common keychain');
+            }
+            const commonKeychain = transaction.coinSpecific.commonKeychain;
+            if (!transaction.derivationPath) {
+                throw new Error('Missing derivation path');
+            }
+            const derivationPath = transaction.derivationPath;
+            const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+            const senderAddr = this.getAddressFromPublicKey(accountId);
+            let signatureHex;
+            if (mpcv2SignatureHex) {
+                // MPCv2 (OVC 5-pass): raw 64-byte Ed25519 signature. Verify against the
+                // same derived public key the transaction is signed under, then embed as-is.
+                const signature = Buffer.from(mpcv2SignatureHex, 'hex');
+                const isValid = tweetnacl_1.default.sign.detached.verify(messageBuffer, signature, Buffer.from(accountId, 'hex'));
+                if (!isValid) {
+                    throw new Error('Invalid signature');
+                }
+                signatureHex = signature;
+            }
+            else {
+                const result = MPC.verify(messageBuffer, ovc.eddsaSignature);
+                if (!result) {
+                    throw new Error('Invalid signature');
+                }
+                signatureHex = Buffer.concat([
+                    Buffer.from(ovc.eddsaSignature.R, 'hex'),
+                    Buffer.from(ovc.eddsaSignature.sigma, 'hex'),
+                ]);
+            }
+            const txnBuilder = this.getBuilder()
+                .material(material)
+                .from(transaction.serializedTx)
+                .sender({ address: senderAddr })
+                .validity(validityWindow);
+            const dotKeyPair = new lib_1.KeyPair({ pub: accountId });
+            txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, signatureHex);
+            const signedTransaction = await txnBuilder.build();
+            const serializedTx = signedTransaction.toBroadcastFormat();
+            broadcastableTransactions.push({
+                serializedTx: serializedTx,
+                scanIndex: transaction.scanIndex,
+            });
+            if (i === req.length - 1 && transaction.coinSpecific.lastScanIndex) {
+                lastScanIndex = transaction.coinSpecific.lastScanIndex;
+            }
+        }
+        return { transactions: broadcastableTransactions, lastScanIndex };
+    }
+    async parseTransaction(params) {
+        return {};
+    }
+    async isWalletAddress(params) {
+        return (0, sdk_core_1.verifyEddsaTssWalletAddress)(params, (address) => this.isValidAddress(address), (publicKey) => this.getAddressFromPublicKey(publicKey));
+    }
+    async verifyTransaction(params) {
+        const { txPrebuild, txParams, verification, wallet, reqId } = params;
+        if (!txParams) {
+            throw new Error('missing txParams');
+        }
+        if (!txPrebuild) {
+            throw new Error('missing txPrebuild');
+        }
+        if (!txPrebuild.txHex) {
+            throw new Error('missing txHex in txPrebuild');
+        }
+        const chain = this.getChain();
+        let txTo;
+        let txAmount;
+        let isSweep;
+        if (chain === 'tdot') {
+            const material = lib_1.Utils.default.getMaterial(statics_1.coins.get(chain));
+            const explained = (0, lib_1.explainDotTransaction)({ txHex: txPrebuild.txHex, material });
+            txTo = explained.outputs[0]?.address ?? '';
+            txAmount = String(explained.outputs[0]?.amount ?? '0');
+            isSweep = explained.methodName === 'balances.transferAll';
+        }
+        else {
+            const factory = this.getBuilder();
+            const txBuilder = factory.from(txPrebuild.txHex);
+            txTo = txBuilder['_to'];
+            txAmount = txBuilder['_amount'];
+            isSweep = txBuilder['_sweepFreeBalance'] === true;
+        }
+        if (verification?.consolidationToBaseAddress) {
+            const baseAddress = wallet?.coinSpecific()?.rootAddress || wallet?.coinSpecific()?.baseAddress;
+            if (!baseAddress) {
+                throw new Error('Unable to determine base address for consolidation');
+            }
+            if (txTo !== baseAddress) {
+                throw new sdk_core_1.TxIntentMismatchRecipientError(`Transaction destination address ${txTo} does not match wallet base address ${baseAddress}`, reqId, [txParams], txPrebuild.txHex, [{ address: txTo, amount: txAmount }]);
+            }
+        }
+        if (txParams.recipients !== undefined) {
+            if (txParams.recipients.length === 0) {
+                throw new Error('missing recipients in txParams');
+            }
+            if (Array.isArray(txParams.recipients) && txParams.recipients.length > 1) {
+                throw new Error(`${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`);
+            }
+            if (txParams.recipients[0].address !== txTo) {
+                throw new sdk_core_1.TxIntentMismatchRecipientError(`Recipient address ${txParams.recipients[0].address} does not match transaction destination address ${txTo}`, reqId, [txParams], txPrebuild.txHex, [{ address: txTo, amount: txAmount }]);
+            }
+            if (!isSweep && txParams.recipients[0].amount !== txAmount) {
+                throw new sdk_core_1.TxIntentMismatchRecipientError(`Recipient amount ${txParams.recipients[0].amount} does not match transaction amount ${txAmount}`, reqId, [txParams], txPrebuild.txHex, [{ address: txTo, amount: txAmount }]);
+            }
+        }
+        return true;
+    }
+    getAddressFromPublicKey(Pubkey) {
+        return new lib_1.KeyPair({ pub: Pubkey }).getAddress(lib_1.Utils.default.getAddressFormat(this.getChain()));
+    }
+    getBuilder() {
+        return new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+    }
+    /**
+     * Detects whether a keycard's decrypted plaintext is MPCv1 JSON or MPCv2 CBOR.
+     * Unsigned sweeps (no walletPassphrase) have no keycard to inspect and default to MPCv1.
+     */
+    async getEddsaSigningMaterial(userKey, walletPassphrase) {
+        return (0, sdk_core_1.getEddsaSigningMaterial)(userKey.replace(/\s/g, ''), walletPassphrase, this.bitgo);
+    }
+    async signDotMpcV2Recovery(params) {
+        return (0, sdk_core_1.signEddsaMpcV2RecoveryTx)(params);
+    }
+    /**
+     * Adds an MPCv1 or MPCv2 signature to a DOT transaction builder.
+     *
+     * Transaction#constructSignedPayload already prepends the 0x00 type-tag (the Substrate
+     * MultiSignature enum discriminant for Ed25519) to whatever signature buffer is passed to
+     * addSignature, so both paths here hand off the raw 64-byte signature untouched.
+     */
+    async addRecoverySignature(signingMaterial, backupKey, walletPassphrase, txnBuilder, accountId, unsignedTransaction, currPath, bitgoKey) {
+        const dotKeyPair = new lib_1.KeyPair({ pub: accountId });
+        if (signingMaterial.version === 'v2') {
+            const rawSig = await this.signDotMpcV2Recovery({
+                message: unsignedTransaction.signablePayload,
+                userKey: signingMaterial.encryptedUserKey,
+                backupKey,
+                walletPassphrase,
+                bitgoKey,
+                derivationPath: currPath,
+                bitgo: this.bitgo,
+            });
+            txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, rawSig);
+        }
+        else {
+            /** TODO BG-52419 Implement Codec for parsing */
+            const userSigningMaterial = JSON.parse(signingMaterial.userPrv);
+            const backupPrv = await (0, sdk_core_1.decryptKeychainPrivateKey)(this.bitgo, { encryptedPrv: backupKey }, walletPassphrase);
+            if (!backupPrv) {
+                throw new Error('Error decrypting backup keychain: invalid password or corrupted key');
+            }
+            const backupSigningMaterial = JSON.parse(backupPrv);
+            const signatureHex = await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, currPath, unsignedTransaction);
+            txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, signatureHex);
+        }
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ publicKey, prv, multiSigType }) {
+        if (multiSigType !== 'tss') {
+            throw new Error('Unsupported multiSigType');
+        }
+        (0, sdk_lib_mpc_1.auditEddsaPrivateKey)(prv, publicKey ?? '');
+    }
+}
+exports.Dot = Dot;
+Dot.initialized = false;
+Dot.nodeApiInitialized = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"dot.js","sourceRoot":"","sources":["../../../src/dot.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,oDAA4B;AAC5B,0CAA4B;AAC5B,mDAqC8B;AAC9B,iDAA+F;AAC/F,+BAQe;AACf,iCAA+B;AAC/B,uCAAuD;AAEvD,gEAAqC;AACrC,yDAAkF;AAClF,0DAA6B;AAEhB,QAAA,mBAAmB,GAAG,EAAE,CAAC,CAAC,wDAAwD;AAiB/F,MAAM,QAAQ,GAAG,WAAK,CAAC,OAAO,CAAC;AAE/B,SAAS,sBAAsB,CAAC,KAAc;IAC5C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,CAAC,CAAC,SAAS,IAAI,KAAK,CAAC,EAAE,CAAC;QAC1B,OAAO,KAAK,CAAC;IACf,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,SAAS,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,OAAO,KAAK,QAAQ,CAAC;IACjE,CAAC;IACD,IAAI,KAAK,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO,kBAAkB,IAAI,KAAK,IAAI,OAAO,KAAK,CAAC,gBAAgB,KAAK,QAAQ,CAAC;IACnF,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED,MAAa,GAAI,SAAQ,mBAAQ;IAK/B,YAAY,KAAgB,EAAE,WAAuC;QACnE,KAAK,CAAC,KAAK,CAAC,CAAC;QAJN,0BAAqB,GAAG,IAAI,CAAC;QAC7B,uBAAkB,GAAG,EAAE,CAAC;QAK/B,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QAED,IAAI,CAAC,YAAY,GAAG,WAAW,CAAC;IAClC,CAAC;IAOD,MAAM,CAAC,cAAc,CAAC,KAAgB,EAAE,WAAuC;QAC7E,OAAO,IAAI,GAAG,CAAC,KAAK,EAAE,WAAW,CAAC,CAAC;IACrC,CAAC;IAED,QAAQ;QACN,OAAO,KAAK,CAAC;IACf,CAAC;IAED,YAAY;QACV,OAAO,KAAK,CAAC;IACf,CAAC;IAED,SAAS;QACP,OAAO,KAAK,CAAC;IACf,CAAC;IAED,WAAW;QACT,OAAO,UAAU,CAAC;IACpB,CAAC;IAED,aAAa;QACX,OAAO,IAAI,CAAC,GAAG,CAAC,EAAE,EAAE,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,CAAC;IACvD,CAAC;IAED;;;OAGG;IACH,wBAAwB;QACtB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,kBAAkB;IAClB,WAAW;QACT,OAAO,IAAI,CAAC;IACd,CAAC;IAED,oBAAoB;IACpB,sBAAsB;QACpB,OAAO,wBAAa,CAAC,GAAG,CAAC;IAC3B,CAAC;IAED,eAAe;QACb,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,2BAA2B;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACH,eAAe,CAAC,IAAa;QAC3B,MAAM,OAAO,GAAG,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,eAAe,CAAC,IAAI,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,aAAU,EAAE,CAAC;QACzF,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;QAC/B,IAAI,CAAC,IAAI,CAAC,GAAG,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;QACpD,CAAC;QACD,OAAO;YACL,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,GAAG,EAAE,IAAI,CAAC,GAAG;SACd,CAAC;IACJ,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,GAAW;QACpB,OAAO,QAAQ,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC;IACxC,CAAC;IAED;;;;;OAKG;IACH,UAAU,CAAC,GAAW;QACpB,OAAO,QAAQ,CAAC,iBAAiB,CAAC,GAAG,CAAC,CAAC;IACzC,CAAC;IAED;;;;;OAKG;IACH,cAAc,CAAC,OAAe;QAC5B,OAAO,QAAQ,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,WAAW,CAAC,GAAY,EAAE,OAAwB;QACtD,MAAM,GAAG,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC;QAC1E,6BAA6B;QAC7B,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,aAAU,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC,CAAC;IACxE,CAAC;IAED;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CAAC,mBAAwC;QAC/D,IAAI,YAAY,GAAG,CAAC,CAAC;QACrB,mBAAmB,CAAC,QAAQ,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,EAAE;YACjD,YAAY,IAAI,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC;QAC9C,CAAC,CAAC,CAAC;QACH,MAAM,iBAAiB,GAAsB;YAC3C,YAAY,EAAE;gBACZ,cAAc;gBACd,cAAc;gBACd,SAAS;gBACT,eAAe;gBACf,KAAK;gBACL,MAAM;gBACN,YAAY;gBACZ,IAAI;gBACJ,aAAa;aACd;YACD,UAAU,EAAE,mBAAmB,CAAC,QAAQ,CAAC,UAAU;YACnD,GAAG,EAAE,mBAAmB,CAAC,OAAO,EAAE,SAAS;YAC3C,EAAE,EAAE,mBAAmB,CAAC,QAAQ,CAAC,EAAE;YACnC,IAAI,EAAE,mBAAmB,CAAC,QAAQ,CAAC,IAAI;YACvC,OAAO,EAAE,mBAAmB,CAAC,QAAQ,CAAC,OAAO;YAC7C,WAAW,EAAE,mBAAmB,CAAC,YAAY,EAAE,WAAW;YAC1D,YAAY,EAAE,YAAY;YAC1B,aAAa,EAAE,EAAE;YACjB,YAAY,EAAE,GAAG;SAClB,CAAC;QAEF,OAAO,iBAAiB,CAAC;IAC3B,CAAC;IAED,2BAA2B,CAAC,MAA8B;QACxD,MAAM,GAAG,GAAG,MAAM,CAAC,GAAG,CAAC;QAEvB,MAAM,KAAK,GAAG,MAAM,CAAC,UAAU,CAAC,KAAK,CAAC;QAEtC,IAAI,CAAC,KAAK,EAAE,CAAC;YACX,MAAM,IAAI,KAAK,CAAC,8BAA8B,CAAC,CAAC;QAClD,CAAC;QAED,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;YACvB,MAAM,IAAI,KAAK,CAAC,0CAA0C,OAAO,KAAK,EAAE,CAAC,CAAC;QAC5E,CAAC;QAED,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAC;QAC/D,CAAC;QAED,IAAI,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kCAAkC,OAAO,GAAG,EAAE,CAAC,CAAC;QAClE,CAAC;QAED,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,kDAAkD,CAAC,CAAC;QACtE,CAAC;QAED,OAAO,EAAE,KAAK,EAAE,GAAG,EAAE,CAAC;IACxB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,eAAe,CAAC,MAA8B;QAClD,MAAM,EAAE,KAAK,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC,2BAA2B,CAAC,MAAM,CAAC,CAAC;QAChE,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;QAClC,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACtC,MAAM,OAAO,GAAG,IAAI,aAAU,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;QAC7C,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,UAAU,CAAC,WAAW,CAAC;QAElG,SAAS;aACN,QAAQ,CAAC,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC;aAC9E,cAAc,CAAC,cAAc,CAAC;aAC9B,OAAO,CAAC,kBAAkB,CAAC;aAC3B,MAAM,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,CAAC;aAC3B,IAAI,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,CAAC;QACxC,MAAM,WAAW,GAAG,MAAM,SAAS,CAAC,KAAK,EAAE,CAAC;QAC5C,IAAI,CAAC,WAAW,EAAE,CAAC;YACjB,MAAM,IAAI,KAAK,CAAC,qBAAqB,CAAC,CAAC;QACzC,CAAC;QACD,MAAM,WAAW,GAAG,WAAW,CAAC,iBAAiB,EAAE,CAAC;QACpD,OAAO,EAAE,KAAK,EAAE,WAAW,EAAE,CAAC;IAChC,CAAC;IAES,KAAK,CAAC,qBAAqB;QACnC,IAAI,CAAC,GAAG,CAAC,kBAAkB,EAAE,CAAC;YAC5B,MAAM,UAAU,GAAG,IAAI,gBAAU,CAAC,uBAAY,CAAC,IAAI,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC;YACjF,GAAG,CAAC,GAAG,GAAG,MAAM,gBAAU,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,UAAU,EAAE,CAAC,CAAC;YAC5D,GAAG,CAAC,kBAAkB,GAAG,IAAI,CAAC;QAChC,CAAC;QACD,OAAO,GAAG,CAAC,GAAG,CAAC;IACjB,CAAC;IAES,KAAK,CAAC,cAAc,CAAC,UAAkB;QAC/C,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/C,MAAM,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;QAC5E,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC3E,CAAC;IAES,KAAK,CAAC,aAAa;QAC3B,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/C,MAAM,aAAa,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC;QAC7D,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,MAAM,GAAG,CAAC,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,aAAa,CAAC,CAAC;QACtE,OAAO,EAAE,YAAY,EAAE,MAAM,CAAC,QAAQ,EAAE,EAAE,UAAU,EAAE,IAAI,CAAC,QAAQ,EAAE,EAAE,CAAC;IAC1E,CAAC;IAED;;;;;;;;;;OAUG;IACO,KAAK,CAAC,MAAM,CAAC,QAAgB,EAAE,OAAe,EAAE,MAAc;QACtE,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/C,MAAM,IAAI,GAAG,MAAM,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,kBAAkB,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QAC7F,OAAO,IAAI,CAAC,UAAU,CAAC,QAAQ,EAAE,CAAC;IACpC,CAAC;IAES,KAAK,CAAC,WAAW;QACzB,MAAM,GAAG,GAAG,MAAM,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAC/C,OAAO;YACL,WAAW,EAAE,GAAG,CAAC,WAAW,CAAC,QAAQ,EAAE;YACvC,SAAS,EAAE,GAAG,CAAC,YAAY,CAAC,QAAQ,EAAE;YACtC,QAAQ,EAAE,GAAG,CAAC,cAAc,CAAC,QAAQ,CAAC,QAAQ,EAA0B;YACxE,WAAW,EAAE,GAAG,CAAC,cAAc,CAAC,WAAW,CAAC,QAAQ,EAAE;YACtD,SAAS,EAAE,GAAG,CAAC,cAAc,CAAC,kBAAkB,CAAC,QAAQ,EAAE;YAC3D,QAAQ,EAAE,GAAG,CAAC,eAAe,CAAC,KAAK,EAAE;SACtC,CAAC;IACJ,CAAC;IAED;;;;;;;;;OASG;IACH,KAAK,CAAC,OAAO,CAAC,MAA0B,EAAE,mBAA0C;QAClF,IAAI,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;YACrB,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACtC,CAAC;QACD,IAAI,CAAC,MAAM,CAAC,mBAAmB,IAAI,CAAC,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,mBAAmB,CAAC,EAAE,CAAC;YACpF,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACpD,MAAM,eAAe,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;QAEzF,MAAM,GAAG,GAAG,MAAM,uBAAY,CAAC,yBAAyB,EAAE,CAAC;QAE3D,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,IAAI,CAAC,CAAC;QAChC,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,+BAAiB,EAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC;QAC3F,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACxE,MAAM,UAAU,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAE3D,IAAI,WAAW,CAAC;QAChB,IAAI,UAAU,CAAC;QACf,IAAI,CAAC;YACH,WAAW,GAAG,MAAM,IAAI,CAAC,cAAc,CAAC,UAAU,CAAC,CAAC;YACpD,UAAU,GAAG,MAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,mBAAmB,EAAE,UAAU,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;QAClG,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,gCAAqB,CAAC,8CAA8C,UAAU,EAAE,EAAE,CAAC,CAAC,CAAC;QACjG,CAAC;QACD,MAAM,EAAE,KAAK,EAAE,WAAW,EAAE,GAAG,WAAW,CAAC;QAE3C,MAAM,KAAK,GAAG,IAAI,sBAAS,CAAC,WAAW,CAAC,CAAC,KAAK,CAAC,IAAI,sBAAS,CAAC,UAAU,CAAC,CAAC,CAAC;QAC1E,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,gCAAqB,CAAC,4CAA4C,CAAC,CAAC;QAChF,CAAC;QAED,+BAA+B;QAC/B,IAAI,UAAU,CAAC;QACf,IAAI,QAAQ,CAAC;QACb,IAAI,CAAC;YACH,UAAU,GAAG,MAAM,IAAI,CAAC,aAAa,EAAE,CAAC;YACxC,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;QACtC,CAAC;QAAC,OAAO,CAAC,EAAE,CAAC;YACX,MAAM,IAAI,gCAAqB,CAAC,0CAA0C,EAAE,CAAC,CAAC,CAAC;QACjF,CAAC;QACD,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,GAAG,UAAU,CAAC;QAChD,MAAM,cAAc,GAAG,EAAE,UAAU,EAAE,YAAY,EAAE,WAAW,EAAE,IAAI,CAAC,qBAAqB,EAAE,CAAC;QAE7F,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC,kBAAkB,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC;QAC7E,UAAU;aACP,KAAK,CAAC,KAAK,CAAC;aACZ,EAAE,CAAC,EAAE,OAAO,EAAE,MAAM,CAAC,mBAAmB,EAAE,CAAC;aAC3C,MAAM,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;aAC/B,QAAQ,CAAC,cAAc,CAAC;aACxB,cAAc,CAAC,UAAU,CAAC;aAC1B,UAAU,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,KAAK,EAAE,CAAC;aAC7D,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACnC,MAAM,mBAAmB,GAAG,CAAC,MAAM,UAAU,CAAC,KAAK,EAAE,CAAgB,CAAC;QAEtE,IAAI,YAAY,GAAG,mBAAmB,CAAC,iBAAiB,EAAE,CAAC;QAC3D,IAAI,CAAC,eAAe,EAAE,CAAC;YACrB,IAAA,gBAAM,EAAC,MAAM,CAAC,OAAO,EAAE,iBAAiB,CAAC,CAAC;YAC1C,IAAA,gBAAM,EAAC,MAAM,CAAC,SAAS,EAAE,mBAAmB,CAAC,CAAC;YAC9C,IAAA,gBAAM,EAAC,MAAM,CAAC,gBAAgB,EAAE,2BAA2B,CAAC,CAAC;YAE7D,MAAM,eAAe,GAAG,sBAAsB,CAAC,mBAAmB,CAAC;gBACjE,CAAC,CAAC,mBAAmB;gBACrB,CAAC,CAAC,MAAM,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,OAAO,EAAE,MAAM,CAAC,gBAAgB,CAAC,CAAC;YAChF,MAAM,IAAI,CAAC,oBAAoB,CAC7B,eAAe,EACf,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EACnC,MAAM,CAAC,gBAAgB,EACvB,UAAU,EACV,SAAS,EACT,mBAAmB,EACnB,QAAQ,EACR,QAAQ,CACT,CAAC;YACF,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;YACnD,YAAY,GAAG,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;QACvD,CAAC;aAAM,CAAC;YACN,MAAM,KAAK,GAAG,IAAI,sBAAS,CAAC,WAAW,CAAC,CAAC;YACzC,MAAM,UAAU,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;YACnC,MAAM,MAAM,GAAG;gBACb;oBACE,OAAO,EAAE,mBAAmB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,OAAO;oBAC9C,WAAW,EAAE,KAAK,CAAC,QAAQ,EAAE;oBAC7B,KAAK,EAAE,KAAK,CAAC,QAAQ,EAAE;iBACxB;aACF,CAAC;YACF,MAAM,OAAO,GAAG;gBACd;oBACE,OAAO,EAAE,mBAAmB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO;oBAC/C,WAAW,EAAE,KAAK,CAAC,QAAQ,EAAE;oBAC7B,QAAQ,EAAE,UAAU;iBACrB;aACF,CAAC;YACF,MAAM,WAAW,GAAG,KAAK,CAAC,QAAQ,EAAE,CAAC;YACrC,MAAM,QAAQ,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC;YAC1F,MAAM,OAAO,GAAG,EAAE,GAAG,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC;YAC3C,MAAM,WAAW,GAAU;gBACzB,YAAY,EAAE,YAAY;gBAC1B,SAAS,EAAE,KAAK;gBAChB,IAAI,EAAE,UAAU;gBAChB,WAAW,EAAE,mBAAmB,CAAC,eAAe,CAAC,QAAQ,CAAC,KAAK,CAAC;gBAChE,cAAc,EAAE,QAAQ;gBACxB,QAAQ,EAAE,QAAQ;gBAClB,OAAO,EAAE,OAAO;gBAChB,YAAY,EAAE,EAAE,GAAG,cAAc,EAAE,cAAc,EAAE,QAAQ,EAAE;aAC9D,CAAC;YAEF,MAAM,UAAU,GAAkB,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,EAAE,EAAE,CAAC;YACnF,MAAM,YAAY,GAAoB,CAAC,UAAU,CAAC,CAAC;YACnD,MAAM,SAAS,GAAsB;gBACnC,YAAY,EAAE,YAAY;gBAC1B,UAAU,EAAE,UAAU;aACvB,CAAC;YACF,MAAM,UAAU,GAAgB,EAAE,UAAU,EAAE,CAAC,SAAS,CAAC,EAAE,CAAC;YAC5D,OAAO,UAAU,CAAC;QACpB,CAAC;QACD,MAAM,WAAW,GAAU,EAAE,YAAY,EAAE,YAAY,EAAE,SAAS,EAAE,KAAK,EAAE,CAAC;QAC5E,OAAO,WAAW,CAAC;IACrB,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CAAC,qBAAqB,CAAC,MAAuC;QACjE,MAAM,eAAe,GAAG,CAAC,MAAM,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,SAAS,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC;QACzF,MAAM,QAAQ,GAAG,MAAM,CAAC,iBAAiB,IAAI,CAAC,CAAC;QAC/C,MAAM,MAAM,GAAG,MAAM,CAAC,eAAe,IAAI,QAAQ,GAAG,2BAAmB,CAAC;QAExE,IAAI,QAAQ,GAAG,CAAC,IAAI,MAAM,IAAI,QAAQ,IAAI,MAAM,GAAG,QAAQ,GAAG,EAAE,GAAG,2BAAmB,EAAE,CAAC;YACvF,MAAM,IAAI,KAAK,CACb,8EAA8E,QAAQ,sBAAsB,MAAM,GAAG,CACtH,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QACpD,MAAM,GAAG,GAAG,MAAM,uBAAY,CAAC,yBAAyB,EAAE,CAAC;QAC3D,MAAM,SAAS,GAAG,CAAC,CAAC;QACpB,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,IAAA,+BAAiB,EAAC,MAAM,CAAC,IAAI,CAAC,GAAG,IAAI,SAAS,EAAE,CAAC,CAAC,CAAC,KAAK,SAAS,EAAE,CAAC;QACnG,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QACxE,MAAM,WAAW,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;QAE5D,2FAA2F;QAC3F,MAAM,eAAe,GACnB,MAAM,CAAC,gBAAgB,IAAI,MAAM,CAAC,OAAO;YACvC,CAAC,CAAC,MAAM,IAAI,CAAC,uBAAuB,CAAC,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,MAAM,CAAC,gBAAgB,CAAC;YAChG,CAAC,CAAC,SAAS,CAAC;QAEhB,MAAM,yBAAyB,GAAU,EAAE,CAAC;QAC5C,IAAI,aAAa,GAAG,QAAQ,CAAC;QAC7B,KAAK,IAAI,CAAC,GAAG,QAAQ,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACvC,MAAM,aAAa,GAAuB;gBACxC,OAAO,EAAE,MAAM,CAAC,OAAO;gBACvB,SAAS,EAAE,MAAM,CAAC,SAAS;gBAC3B,QAAQ,EAAE,MAAM,CAAC,QAAQ;gBACzB,gBAAgB,EAAE,MAAM,CAAC,gBAAgB;gBACzC,mBAAmB,EAAE,WAAW;gBAChC,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,KAAK,EAAE,CAAC;aACT,CAAC;YAEF,IAAI,mBAAmB,CAAC;YACxB,IAAI,CAAC;gBACH,mBAAmB,GAAG,MAAM,IAAI,CAAC,OAAO,CAAC,aAAa,EAAE,eAAe,CAAC,CAAC;YAC3E,CAAC;YAAC,OAAO,CAAC,EAAE,CAAC;gBACX,IAAI,CAAC,YAAY,gCAAqB,EAAE,CAAC;oBACvC,aAAa,GAAG,CAAC,CAAC;oBAClB,SAAS;gBACX,CAAC;gBACD,MAAM,CAAC,CAAC;YACV,CAAC;YAED,IAAI,eAAe,EAAE,CAAC;gBACpB,yBAAyB,CAAC,IAAI,CAAE,mBAAmC,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;YACrF,CAAC;iBAAM,CAAC;gBACN,yBAAyB,CAAC,IAAI,CAAC,mBAAmB,CAAC,CAAC;YACtD,CAAC;YACD,aAAa,GAAG,CAAC,CAAC;QACpB,CAAC;QAED,IAAI,yBAAyB,CAAC,MAAM,IAAI,CAAC,EAAE,CAAC;YAC1C,MAAM,IAAI,gCAAqB,CAAC,+CAA+C,CAAC,CAAC;QACnF,CAAC;QAED,IAAI,eAAe,EAAE,CAAC;YACpB,4GAA4G;YAC5G,kHAAkH;YAClH,sGAAsG;YACtG,MAAM,2BAA2B,GAAG;gBAClC,UAAU,EACR,yBAAyB,CAAC,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY;qBACpG,UAAU;gBACf,WAAW,EACT,yBAAyB,CAAC,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY;qBACpG,WAAW;gBAChB,cAAc,EACZ,yBAAyB,CAAC,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY;qBACpG,cAAc;gBACnB,aAAa,EAAE,aAAa;aAC7B,CAAC;YACF,yBAAyB,CAAC,yBAAyB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,YAAY;gBACrG,2BAA2B,CAAC;YAC9B,MAAM,8BAA8B,GAAgB,EAAE,UAAU,EAAE,yBAAyB,EAAE,CAAC;YAC9F,OAAO,8BAA8B,CAAC;QACxC,CAAC;QAED,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,aAAa,EAAE,CAAC;IACpE,CAAC;IAED,oBAAoB;IACpB,KAAK,CAAC,mCAAmC,CAAC,MAA+B;QACvE,MAAM,GAAG,GAAG,MAAM,CAAC,eAAe,CAAC;QACnC,MAAM,yBAAyB,GAAY,EAAE,CAAC;QAC9C,IAAI,aAAa,GAAG,CAAC,CAAC;QAEtB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;YACpC,MAAM,GAAG,GAAG,MAAM,uBAAY,CAAC,yBAAyB,EAAE,CAAC;YAC3D,MAAM,WAAW,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC;YAChE,MAAM,GAAG,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;YAC5B,MAAM,iBAAiB,GAAG,GAAG,EAAE,mBAAmB,CAAC;YACnD,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC,iBAAiB,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,EAAE,CAAC;gBACxD,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;YAC1C,CAAC;YACD,IAAI,CAAC,WAAW,CAAC,WAAW,EAAE,CAAC;gBAC7B,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAC;YAC1C,CAAC;YACD,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,WAAW,CAAC,WAAY,EAAE,KAAK,CAAC,CAAC;YACnE,IACE,CAAC,WAAW,CAAC,YAAY;gBACzB,CAAC,WAAW,CAAC,YAAY,EAAE,UAAU;gBACrC,CAAC,WAAW,CAAC,YAAY,EAAE,WAAW,EACtC,CAAC;gBACD,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;YAC7C,CAAC;YACD,MAAM,cAAc,GAAG;gBACrB,UAAU,EAAE,WAAW,CAAC,YAAY,EAAE,UAAU;gBAChD,WAAW,EAAE,WAAW,CAAC,YAAY,EAAE,WAAW;aACnD,CAAC;YACF,MAAM,QAAQ,GAAG,MAAM,IAAI,CAAC,WAAW,EAAE,CAAC;YAC1C,IAAI,CAAC,WAAW,CAAC,YAAY,EAAE,cAAc,EAAE,CAAC;gBAC9C,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;YAC7C,CAAC;YACD,MAAM,cAAc,GAAG,WAAW,CAAC,YAAa,CAAC,cAAyB,CAAC;YAC3E,IAAI,CAAC,WAAW,CAAC,cAAc,EAAE,CAAC;gBAChC,MAAM,IAAI,KAAK,CAAC,yBAAyB,CAAC,CAAC;YAC7C,CAAC;YACD,MAAM,cAAc,GAAG,WAAW,CAAC,cAAwB,CAAC;YAC5D,MAAM,SAAS,GAAG,GAAG,CAAC,gBAAgB,CAAC,cAAc,EAAE,cAAc,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;YACpF,MAAM,UAAU,GAAG,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CAAC;YAC3D,IAAI,YAAoB,CAAC;YACzB,IAAI,iBAAiB,EAAE,CAAC;gBACtB,wEAAwE;gBACxE,6EAA6E;gBAC7E,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,EAAE,KAAK,CAAC,CAAC;gBACxD,MAAM,OAAO,GAAG,mBAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,aAAa,EAAE,SAAS,EAAE,MAAM,CAAC,IAAI,CAAC,SAAS,EAAE,KAAK,CAAC,CAAC,CAAC;gBACnG,IAAI,CAAC,OAAO,EAAE,CAAC;oBACb,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBACvC,CAAC;gBACD,YAAY,GAAG,SAAS,CAAC;YAC3B,CAAC;iBAAM,CAAC;gBACN,MAAM,MAAM,GAAG,GAAG,CAAC,MAAM,CAAC,aAAa,EAAE,GAAG,CAAC,cAAc,CAAC,CAAC;gBAC7D,IAAI,CAAC,MAAM,EAAE,CAAC;oBACZ,MAAM,IAAI,KAAK,CAAC,mBAAmB,CAAC,CAAC;gBACvC,CAAC;gBACD,YAAY,GAAG,MAAM,CAAC,MAAM,CAAC;oBAC3B,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,CAAC,EAAE,KAAK,CAAC;oBACxC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,cAAc,CAAC,KAAK,EAAE,KAAK,CAAC;iBAC7C,CAAC,CAAC;YACL,CAAC;YACD,MAAM,UAAU,GAAG,IAAI,CAAC,UAAU,EAAE;iBACjC,QAAQ,CAAC,QAAQ,CAAC;iBAClB,IAAI,CAAC,WAAW,CAAC,YAAsB,CAAC;iBACxC,MAAM,CAAC,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;iBAC/B,QAAQ,CAAC,cAAc,CAAC,CAAC;YAC5B,MAAM,UAAU,GAAG,IAAI,aAAU,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;YACtD,UAAU,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,YAAY,CAAC,CAAC;YACzE,MAAM,iBAAiB,GAAG,MAAM,UAAU,CAAC,KAAK,EAAE,CAAC;YACnD,MAAM,YAAY,GAAG,iBAAiB,CAAC,iBAAiB,EAAE,CAAC;YAE3D,yBAAyB,CAAC,IAAI,CAAC;gBAC7B,YAAY,EAAE,YAAY;gBAC1B,SAAS,EAAE,WAAW,CAAC,SAAS;aACjC,CAAC,CAAC;YAEH,IAAI,CAAC,KAAK,GAAG,CAAC,MAAM,GAAG,CAAC,IAAI,WAAW,CAAC,YAAa,CAAC,aAAa,EAAE,CAAC;gBACpE,aAAa,GAAG,WAAW,CAAC,YAAa,CAAC,aAAuB,CAAC;YACpE,CAAC;QACH,CAAC;QACD,OAAO,EAAE,YAAY,EAAE,yBAAyB,EAAE,aAAa,EAAE,CAAC;IACpE,CAAC;IAED,KAAK,CAAC,gBAAgB,CAAC,MAA+B;QACpD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,KAAK,CAAC,eAAe,CAAC,MAA+B;QACnD,OAAO,IAAA,sCAA2B,EAChC,MAAM,EACN,CAAC,OAAO,EAAE,EAAE,CAAC,IAAI,CAAC,cAAc,CAAC,OAAO,CAAC,EACzC,CAAC,SAAS,EAAE,EAAE,CAAC,IAAI,CAAC,uBAAuB,CAAC,SAAS,CAAC,CACvD,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,iBAAiB,CAAC,MAAgC;QACtD,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,MAAM,CAAC;QACrE,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,kBAAkB,CAAC,CAAC;QACtC,CAAC;QAED,IAAI,CAAC,UAAU,EAAE,CAAC;YAChB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;QACxC,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,KAAK,EAAE,CAAC;YACtB,MAAM,IAAI,KAAK,CAAC,6BAA6B,CAAC,CAAC;QACjD,CAAC;QAED,MAAM,KAAK,GAAG,IAAI,CAAC,QAAQ,EAAE,CAAC;QAC9B,IAAI,IAAY,CAAC;QACjB,IAAI,QAAgB,CAAC;QACrB,IAAI,OAAgB,CAAC;QAErB,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;YACrB,MAAM,QAAQ,GAAG,WAAK,CAAC,OAAO,CAAC,WAAW,CAAC,eAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7D,MAAM,SAAS,GAAG,IAAA,2BAAqB,EAAC,EAAE,KAAK,EAAE,UAAU,CAAC,KAAK,EAAE,QAAQ,EAAE,CAAC,CAAC;YAC/E,IAAI,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,IAAI,EAAE,CAAC;YAC3C,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,GAAG,CAAC,CAAC;YACvD,OAAO,GAAG,SAAS,CAAC,UAAU,KAAK,sBAAsB,CAAC;QAC5D,CAAC;aAAM,CAAC;YACN,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,EAAE,CAAC;YAClC,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAqC,CAAC;YACrF,IAAI,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;YACxB,QAAQ,GAAG,SAAS,CAAC,SAAS,CAAC,CAAC;YAChC,OAAO,GAAG,SAAS,CAAC,mBAAmB,CAAC,KAAK,IAAI,CAAC;QACpD,CAAC;QAED,IAAI,YAAY,EAAE,0BAA0B,EAAE,CAAC;YAC7C,MAAM,WAAW,GAAG,MAAM,EAAE,YAAY,EAAE,EAAE,WAAW,IAAI,MAAM,EAAE,YAAY,EAAE,EAAE,WAAW,CAAC;YAC/F,IAAI,CAAC,WAAW,EAAE,CAAC;gBACjB,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;YACxE,CAAC;YACD,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;gBACzB,MAAM,IAAI,yCAA8B,CACtC,mCAAmC,IAAI,uCAAuC,WAAW,EAAE,EAC3F,KAAK,EACL,CAAC,QAAQ,CAAC,EACV,UAAU,CAAC,KAAK,EAChB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CACtC,CAAC;YACJ,CAAC;QACH,CAAC;QAED,IAAI,QAAQ,CAAC,UAAU,KAAK,SAAS,EAAE,CAAC;YACtC,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACrC,MAAM,IAAI,KAAK,CAAC,gCAAgC,CAAC,CAAC;YACpD,CAAC;YAED,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,QAAQ,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACzE,MAAM,IAAI,KAAK,CACb,GAAG,IAAI,CAAC,QAAQ,EAAE,oIAAoI,CACvJ,CAAC;YACJ,CAAC;YAED,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;gBAC5C,MAAM,IAAI,yCAA8B,CACtC,qBAAqB,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,OAAO,mDAAmD,IAAI,EAAE,EAC5G,KAAK,EACL,CAAC,QAAQ,CAAC,EACV,UAAU,CAAC,KAAK,EAChB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CACtC,CAAC;YACJ,CAAC;YAED,IAAI,CAAC,OAAO,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,KAAK,QAAQ,EAAE,CAAC;gBAC3D,MAAM,IAAI,yCAA8B,CACtC,oBAAoB,QAAQ,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,MAAM,sCAAsC,QAAQ,EAAE,EACjG,KAAK,EACL,CAAC,QAAQ,CAAC,EACV,UAAU,CAAC,KAAK,EAChB,CAAC,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,CAAC,CACtC,CAAC;YACJ,CAAC;QACH,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,uBAAuB,CAAC,MAAc;QACpC,OAAO,IAAI,aAAU,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,CAAC,CAAC,UAAU,CAAC,WAAK,CAAC,OAAO,CAAC,gBAAgB,CAAC,IAAI,CAAC,QAAQ,EAAmB,CAAC,CAAC,CAAC;IACtH,CAAC;IAEO,UAAU;QAChB,OAAO,IAAI,+BAAyB,CAAC,eAAK,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC,CAAC;IACnE,CAAC;IAED;;;OAGG;IACO,KAAK,CAAC,uBAAuB,CAAC,OAAe,EAAE,gBAAwB;QAC/E,OAAO,IAAA,kCAA6B,EAAC,OAAO,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE,gBAAgB,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC;IACjG,CAAC;IAES,KAAK,CAAC,oBAAoB,CAAC,MAAsD;QACzF,OAAO,IAAA,mCAAwB,EAAC,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;OAMG;IACK,KAAK,CAAC,oBAAoB,CAChC,eAAqC,EACrC,SAAiB,EACjB,gBAAwB,EACxB,UAAiC,EACjC,SAAiB,EACjB,mBAAgC,EAChC,QAAgB,EAChB,QAAgB;QAEhB,MAAM,UAAU,GAAG,IAAI,aAAU,CAAC,EAAE,GAAG,EAAE,SAAS,EAAE,CAAC,CAAC;QAEtD,IAAI,eAAe,CAAC,OAAO,KAAK,IAAI,EAAE,CAAC;YACrC,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,oBAAoB,CAAC;gBAC7C,OAAO,EAAE,mBAAmB,CAAC,eAAe;gBAC5C,OAAO,EAAE,eAAe,CAAC,gBAAgB;gBACzC,SAAS;gBACT,gBAAgB;gBAChB,QAAQ;gBACR,cAAc,EAAE,QAAQ;gBACxB,KAAK,EAAE,IAAI,CAAC,KAAK;aAClB,CAAC,CAAC;YACH,UAAU,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,MAAM,CAAC,CAAC;QACrE,CAAC;aAAM,CAAC;YACN,gDAAgD;YAChD,MAAM,mBAAmB,GAAG,IAAI,CAAC,KAAK,CAAC,eAAe,CAAC,OAAO,CAAyC,CAAC;YACxG,MAAM,SAAS,GAAG,MAAM,IAAA,oCAAyB,EAAC,IAAI,CAAC,KAAK,EAAE,EAAE,YAAY,EAAE,SAAS,EAAE,EAAE,gBAAgB,CAAC,CAAC;YAC7G,IAAI,CAAC,SAAS,EAAE,CAAC;gBACf,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;YACzF,CAAC;YACD,MAAM,qBAAqB,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,CAA2C,CAAC;YAE9F,MAAM,YAAY,GAAG,MAAM,uBAAY,CAAC,eAAe,CACrD,mBAAmB,EACnB,qBAAqB,EACrB,QAAQ,EACR,mBAAmB,CACpB,CAAC;YACF,UAAU,CAAC,YAAY,CAAC,EAAE,GAAG,EAAE,UAAU,CAAC,OAAO,EAAE,CAAC,GAAG,EAAE,EAAE,YAAY,CAAC,CAAC;QAC3E,CAAC;IACH,CAAC;IAED,kBAAkB;IAClB,iBAAiB,CAAC,EAAE,SAAS,EAAE,GAAG,EAAE,YAAY,EAA2B;QACzE,IAAI,YAAY,KAAK,KAAK,EAAE,CAAC;YAC3B,MAAM,IAAI,KAAK,CAAC,0BAA0B,CAAC,CAAC;QAC9C,CAAC;QACD,IAAA,kCAAoB,EAAC,GAAG,EAAE,SAAS,IAAI,EAAE,CAAC,CAAC;IAC7C,CAAC;;AA9uBH,kBA+uBC;AAhuBkB,eAAW,GAAG,KAAK,AAAR,CAAS;AAEpB,sBAAkB,GAAG,KAAK,AAAR,CAAS","sourcesContent":["import assert from 'assert';\nimport * as _ from 'lodash';\nimport {\n  BaseCoin,\n  BitGoBase,\n  DotAssetTypes,\n  Eddsa,\n  Environments,\n  ErrorNoInputToRecover,\n  ExplanationResult,\n  KeyPair,\n  MPCAlgorithm,\n  ParsedTransaction,\n  ParseTransactionOptions,\n  SignedTransaction,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  UnsignedTransaction,\n  VerifyTransactionOptions,\n  TssVerifyAddressOptions,\n  EDDSAMethods,\n  EDDSAMethodTypes,\n  MPCTx,\n  MPCRecoveryOptions,\n  MPCConsolidationRecoveryOptions,\n  MPCSweepTxs,\n  RecoveryTxRequest,\n  RecoveryProviderError,\n  MPCUnsignedTx,\n  MPCSweepRecoveryOptions,\n  MPCTxs,\n  MultisigType,\n  multisigTypes,\n  AuditDecryptedKeyParams,\n  verifyEddsaTssWalletAddress,\n  TxIntentMismatchRecipientError,\n  getEddsaSigningMaterial as sharedGetEddsaSigningMaterial,\n  signEddsaMpcV2RecoveryTx,\n  EddsaSigningMaterial,\n  decryptKeychainPrivateKey,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, coins, PolkadotSpecNameType } from '@bitgo-beta/statics';\nimport {\n  Interface,\n  KeyPair as DotKeyPair,\n  NativeTransferBuilder,\n  Transaction,\n  TransactionBuilderFactory,\n  Utils,\n  explainDotTransaction,\n} from './lib';\nimport '@polkadot/api-augment';\nimport { ApiPromise, WsProvider } from '@polkadot/api';\nimport { Material } from './lib/iface';\nimport BigNumber from 'bignumber.js';\nimport { auditEddsaPrivateKey, getDerivationPath } from '@bitgo-beta/sdk-lib-mpc';\nimport nacl from 'tweetnacl';\n\nexport const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds\n\nexport interface SignTransactionOptions extends BaseSignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TransactionPrebuild {\n  txHex: string;\n  transaction: Interface.TxData;\n}\n\nexport interface VerifiedTransactionParameters {\n  txHex: string;\n  prv: string;\n}\n\nconst dotUtils = Utils.default;\n\nfunction isEddsaSigningMaterial(value: unknown): value is EddsaSigningMaterial {\n  if (typeof value !== 'object' || value === null) {\n    return false;\n  }\n  if (!('version' in value)) {\n    return false;\n  }\n  if (value.version === 'v1') {\n    return 'userPrv' in value && typeof value.userPrv === 'string';\n  }\n  if (value.version === 'v2') {\n    return 'encryptedUserKey' in value && typeof value.encryptedUserKey === 'string';\n  }\n  return false;\n}\n\nexport class Dot extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n  readonly MAX_VALIDITY_DURATION = 2400;\n  readonly SWEEP_TXN_DURATION = 64;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\n\n    if (!staticsCoin) {\n      throw new Error('missing required constructor parameter staticsCoin');\n    }\n\n    this._staticsCoin = staticsCoin;\n  }\n\n  protected static initialized = false;\n  protected static MPC: Eddsa;\n  protected static nodeApiInitialized = false;\n  protected static API: ApiPromise;\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Dot(bitgo, staticsCoin);\n  }\n\n  getChain(): string {\n    return 'dot';\n  }\n\n  getBaseChain(): string {\n    return 'dot';\n  }\n\n  getFamily(): string {\n    return 'dot';\n  }\n\n  getFullName(): string {\n    return 'Polkadot';\n  }\n\n  getBaseFactor(): number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  /**\n   * Flag for sending value of 0\n   * @returns {boolean} True if okay to send 0 value, false otherwise\n   */\n  valuelessTransferAllowed(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'eddsa';\n  }\n\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  /**\n   * Generate ed25519 key pair\n   *\n   * @param seed\n   * @returns {Object} object with generated pub, prv\n   */\n  generateKeyPair(seed?: Buffer): KeyPair {\n    const keyPair = seed ? dotUtils.keyPairFromSeed(new Uint8Array(seed)) : new DotKeyPair();\n    const keys = keyPair.getKeys();\n    if (!keys.prv) {\n      throw new Error('Missing prv in key generation.');\n    }\n    return {\n      pub: keys.pub,\n      prv: keys.prv,\n    };\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin.\n   *\n   * @param {String} pub the pub to be checked\n   * @returns {Boolean} is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    return dotUtils.isValidPublicKey(pub);\n  }\n\n  /**\n   * Return boolean indicating whether the supplied private key is a valid dot private key\n   *\n   * @param {String} prv the prv to be checked\n   * @returns {Boolean} is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    return dotUtils.isValidPrivateKey(prv);\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {String} address the pub to be checked\n   * @returns {Boolean} is it valid?\n   */\n  isValidAddress(address: string): boolean {\n    return dotUtils.isValidAddress(address);\n  }\n\n  /**\n   * Sign message with private key\n   *\n   * @param key\n   * @param message\n   * @return {Buffer} A signature over the given message using the given key\n   */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const msg = Buffer.isBuffer(message) ? message.toString('utf8') : message;\n    // reconstitute keys and sign\n    return Buffer.from(new DotKeyPair({ prv: key.prv }).signMessage(msg));\n  }\n\n  /**\n   * Explain/parse transaction\n   * @param unsignedTransaction\n   */\n  async explainTransaction(unsignedTransaction: UnsignedTransaction): Promise<ExplanationResult> {\n    let outputAmount = 0;\n    unsignedTransaction.parsedTx.outputs.forEach((o) => {\n      outputAmount += parseInt(o.valueString, 10);\n    });\n    const explanationResult: ExplanationResult = {\n      displayOrder: [\n        'outputAmount',\n        'changeAmount',\n        'outputs',\n        'changeOutputs',\n        'fee',\n        'type',\n        'sequenceId',\n        'id',\n        'blockNumber',\n      ],\n      sequenceId: unsignedTransaction.parsedTx.sequenceId,\n      fee: unsignedTransaction.feeInfo?.feeString,\n      id: unsignedTransaction.parsedTx.id,\n      type: unsignedTransaction.parsedTx.type,\n      outputs: unsignedTransaction.parsedTx.outputs,\n      blockNumber: unsignedTransaction.coinSpecific?.blockNumber,\n      outputAmount: outputAmount,\n      changeOutputs: [],\n      changeAmount: '0',\n    };\n\n    return explanationResult;\n  }\n\n  verifySignTransactionParams(params: SignTransactionOptions): VerifiedTransactionParameters {\n    const prv = params.prv;\n\n    const txHex = params.txPrebuild.txHex;\n\n    if (!txHex) {\n      throw new Error('missing txPrebuild parameter');\n    }\n\n    if (!_.isString(txHex)) {\n      throw new Error(`txPrebuild must be an object, got type ${typeof txHex}`);\n    }\n\n    if (!prv) {\n      throw new Error('missing prv parameter to sign transaction');\n    }\n\n    if (!_.isString(prv)) {\n      throw new Error(`prv must be a string, got type ${typeof prv}`);\n    }\n\n    if (!_.has(params, 'pubs')) {\n      throw new Error('missing public key parameter to sign transaction');\n    }\n\n    return { txHex, prv };\n  }\n\n  /**\n   * Assemble keychain and half-sign prebuilt transaction\n   *\n   * @param params\n   * @param params.txPrebuild {TransactionPrebuild} prebuild object returned by platform\n   * @param params.prv {String} user prv\n   * @returns {Promise<SignedTransaction>}\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    const { txHex, prv } = this.verifySignTransactionParams(params);\n    const factory = this.getBuilder();\n    const txBuilder = factory.from(txHex);\n    const keyPair = new DotKeyPair({ prv: prv });\n    const { referenceBlock, blockNumber, transactionVersion, sender } = params.txPrebuild.transaction;\n\n    txBuilder\n      .validity({ firstValid: blockNumber, maxDuration: this.MAX_VALIDITY_DURATION })\n      .referenceBlock(referenceBlock)\n      .version(transactionVersion)\n      .sender({ address: sender })\n      .sign({ key: keyPair.getKeys().prv });\n    const transaction = await txBuilder.build();\n    if (!transaction) {\n      throw new Error('Invalid transaction');\n    }\n    const signedTxHex = transaction.toBroadcastFormat();\n    return { txHex: signedTxHex };\n  }\n\n  protected async getInitializedNodeAPI(): Promise<ApiPromise> {\n    if (!Dot.nodeApiInitialized) {\n      const wsProvider = new WsProvider(Environments[this.bitgo.getEnv()].dotNodeUrls);\n      Dot.API = await ApiPromise.create({ provider: wsProvider });\n      Dot.nodeApiInitialized = true;\n    }\n    return Dot.API;\n  }\n\n  protected async getAccountInfo(walletAddr: string): Promise<{ nonce: number; freeBalance: number }> {\n    const api = await this.getInitializedNodeAPI();\n    const { nonce, data: balance } = await api.query.system.account(walletAddr);\n    return { nonce: nonce.toNumber(), freeBalance: balance.free.toNumber() };\n  }\n\n  protected async getHeaderInfo(): Promise<{ headerNumber: number; headerHash: string }> {\n    const api = await this.getInitializedNodeAPI();\n    const finalizedHash = await api.rpc.chain.getFinalizedHead();\n    const { number, hash } = await api.rpc.chain.getHeader(finalizedHash);\n    return { headerNumber: number.toNumber(), headerHash: hash.toString() };\n  }\n\n  /**\n   *\n   * Estimate the fee of the transaction\n   *\n   * @param {string} destAddr destination wallet address\n   * @param {string} srcAddr source wallet address\n   * @param {string} amount amount to transfer\n   * @returns {number} the estimated fee the transaction will cost\n   *\n   * @see https://polkadot.js.org/docs/api/cookbook/tx#how-do-i-estimate-the-transaction-fees\n   */\n  protected async getFee(destAddr: string, srcAddr: string, amount: number): Promise<number> {\n    const api = await this.getInitializedNodeAPI();\n    const info = await api.tx.balances.transferAllowDeath(destAddr, amount).paymentInfo(srcAddr);\n    return info.partialFee.toNumber();\n  }\n\n  protected async getMaterial(): Promise<Material> {\n    const api = await this.getInitializedNodeAPI();\n    return {\n      genesisHash: api.genesisHash.toString(),\n      chainName: api.runtimeChain.toString(),\n      specName: api.runtimeVersion.specName.toString() as PolkadotSpecNameType,\n      specVersion: api.runtimeVersion.specVersion.toNumber(),\n      txVersion: api.runtimeVersion.transactionVersion.toNumber(),\n      metadata: api.runtimeMetadata.toHex(),\n    };\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param {MPCRecoveryOptions} params parameters needed to construct and\n   * (maybe) sign the transaction\n   * @param {EddsaSigningMaterial} [precomputedMaterial] optional decrypted\n   * material from recoverConsolidations; non-matching values are ignored\n   *\n   * @returns {MPCTx} the serialized transaction hex string and index\n   * of the address being swept\n   */\n  async recover(params: MPCRecoveryOptions, precomputedMaterial?: EddsaSigningMaterial): Promise<MPCTx | MPCSweepTxs> {\n    if (!params.bitgoKey) {\n      throw new Error('missing bitgoKey');\n    }\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n    const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);\n    const senderAddr = this.getAddressFromPublicKey(accountId);\n\n    let accountInfo;\n    let partialFee;\n    try {\n      accountInfo = await this.getAccountInfo(senderAddr);\n      partialFee = await this.getFee(params.recoveryDestination, senderAddr, accountInfo.freeBalance);\n    } catch (e) {\n      throw new RecoveryProviderError(`Failed to query account balance or fee for ${senderAddr}`, e);\n    }\n    const { nonce, freeBalance } = accountInfo;\n\n    const value = new BigNumber(freeBalance).minus(new BigNumber(partialFee));\n    if (value.isLessThanOrEqualTo(0)) {\n      throw new ErrorNoInputToRecover('Did not find address with funds to recover');\n    }\n\n    // first build the unsigned txn\n    let headerInfo;\n    let material;\n    try {\n      headerInfo = await this.getHeaderInfo();\n      material = await this.getMaterial();\n    } catch (e) {\n      throw new RecoveryProviderError('Failed to query chain header or material', e);\n    }\n    const { headerNumber, headerHash } = headerInfo;\n    const validityWindow = { firstValid: headerNumber, maxDuration: this.MAX_VALIDITY_DURATION };\n\n    const txnBuilder = this.getBuilder().getTransferBuilder().material(material);\n    txnBuilder\n      .sweep(false)\n      .to({ address: params.recoveryDestination })\n      .sender({ address: senderAddr })\n      .validity(validityWindow)\n      .referenceBlock(headerHash)\n      .sequenceId({ name: 'Nonce', keyword: 'nonce', value: nonce })\n      .fee({ amount: 0, type: 'tip' });\n    const unsignedTransaction = (await txnBuilder.build()) as Transaction;\n\n    let serializedTx = unsignedTransaction.toBroadcastFormat();\n    if (!isUnsignedSweep) {\n      assert(params.userKey, 'missing userKey');\n      assert(params.backupKey, 'missing backupKey');\n      assert(params.walletPassphrase, 'missing wallet passphrase');\n\n      const signingMaterial = isEddsaSigningMaterial(precomputedMaterial)\n        ? precomputedMaterial\n        : await this.getEddsaSigningMaterial(params.userKey, params.walletPassphrase);\n      await this.addRecoverySignature(\n        signingMaterial,\n        params.backupKey.replace(/\\s/g, ''),\n        params.walletPassphrase,\n        txnBuilder,\n        accountId,\n        unsignedTransaction,\n        currPath,\n        bitgoKey\n      );\n      const signedTransaction = await txnBuilder.build();\n      serializedTx = signedTransaction.toBroadcastFormat();\n    } else {\n      const value = new BigNumber(freeBalance);\n      const walletCoin = this.getChain();\n      const inputs = [\n        {\n          address: unsignedTransaction.inputs[0].address,\n          valueString: value.toString(),\n          value: value.toNumber(),\n        },\n      ];\n      const outputs = [\n        {\n          address: unsignedTransaction.outputs[0].address,\n          valueString: value.toString(),\n          coinName: walletCoin,\n        },\n      ];\n      const spendAmount = value.toString();\n      const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };\n      const feeInfo = { fee: 0, feeString: '0' };\n      const transaction: MPCTx = {\n        serializedTx: serializedTx,\n        scanIndex: index,\n        coin: walletCoin,\n        signableHex: unsignedTransaction.signablePayload.toString('hex'),\n        derivationPath: currPath,\n        parsedTx: parsedTx,\n        feeInfo: feeInfo,\n        coinSpecific: { ...validityWindow, commonKeychain: bitgoKey },\n      };\n\n      const unsignedTx: MPCUnsignedTx = { unsignedTx: transaction, signatureShares: [] };\n      const transactions: MPCUnsignedTx[] = [unsignedTx];\n      const txRequest: RecoveryTxRequest = {\n        transactions: transactions,\n        walletCoin: walletCoin,\n      };\n      const txRequests: MPCSweepTxs = { txRequests: [txRequest] };\n      return txRequests;\n    }\n    const transaction: MPCTx = { serializedTx: serializedTx, scanIndex: index };\n    return transaction;\n  }\n\n  /**\n   * Builds native DOT recoveries of receive addresses in batch without BitGo.\n   * Funds will be recovered to base address first. You need to initiate another sweep txn after that.\n   *\n   * @param {MPCConsolidationRecoveryOptions} params - options for consolidation recovery.\n   * @param {string} [params.startingScanIndex] - receive address index to start scanning from. default to 1 (inclusive).\n   * @param {string} [params.endingScanIndex] - receive address index to end scanning at. default to startingScanIndex + 20 (exclusive).\n   */\n  async recoverConsolidations(params: MPCConsolidationRecoveryOptions): Promise<MPCTxs | MPCSweepTxs> {\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n    const startIdx = params.startingScanIndex || 1;\n    const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;\n\n    if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {\n      throw new Error(\n        `Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`\n      );\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    const baseIndex = 0;\n    const basePath = params.seed ? getDerivationPath(params.seed) + `/${baseIndex}` : `m/${baseIndex}`;\n    const accountId = MPC.deriveUnhardened(bitgoKey, basePath).slice(0, 64);\n    const baseAddress = this.getAddressFromPublicKey(accountId);\n\n    // Detect signing material once to avoid re-decrypting the keycard on every loop iteration.\n    const signingMaterial =\n      params.walletPassphrase && params.userKey\n        ? await this.getEddsaSigningMaterial(params.userKey.replace(/\\s/g, ''), params.walletPassphrase)\n        : undefined;\n\n    const consolidationTransactions: any[] = [];\n    let lastScanIndex = startIdx;\n    for (let i = startIdx; i < endIdx; i++) {\n      const recoverParams: MPCRecoveryOptions = {\n        userKey: params.userKey,\n        backupKey: params.backupKey,\n        bitgoKey: params.bitgoKey,\n        walletPassphrase: params.walletPassphrase,\n        recoveryDestination: baseAddress,\n        seed: params.seed,\n        index: i,\n      };\n\n      let recoveryTransaction;\n      try {\n        recoveryTransaction = await this.recover(recoverParams, signingMaterial);\n      } catch (e) {\n        if (e instanceof ErrorNoInputToRecover) {\n          lastScanIndex = i;\n          continue;\n        }\n        throw e;\n      }\n\n      if (isUnsignedSweep) {\n        consolidationTransactions.push((recoveryTransaction as MPCSweepTxs).txRequests[0]);\n      } else {\n        consolidationTransactions.push(recoveryTransaction);\n      }\n      lastScanIndex = i;\n    }\n\n    if (consolidationTransactions.length == 0) {\n      throw new ErrorNoInputToRecover('Did not find an address with funds to recover');\n    }\n\n    if (isUnsignedSweep) {\n      // lastScanIndex will be used to inform user the last address index scanned for available funds (so they can\n      // appropriately adjust the scan range on the next iteration of consolidation recoveries). In the case of unsigned\n      // sweep consolidations, this lastScanIndex will be provided in the coinSpecific of the last txn made.\n      const lastTransactionCoinSpecific = {\n        firstValid:\n          consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific\n            .firstValid,\n        maxDuration:\n          consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific\n            .maxDuration,\n        commonKeychain:\n          consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific\n            .commonKeychain,\n        lastScanIndex: lastScanIndex,\n      };\n      consolidationTransactions[consolidationTransactions.length - 1].transactions[0].unsignedTx.coinSpecific =\n        lastTransactionCoinSpecific;\n      const consolidationSweepTransactions: MPCSweepTxs = { txRequests: consolidationTransactions };\n      return consolidationSweepTransactions;\n    }\n\n    return { transactions: consolidationTransactions, lastScanIndex };\n  }\n\n  /** inherited doc */\n  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {\n    const req = params.signatureShares;\n    const broadcastableTransactions: MPCTx[] = [];\n    let lastScanIndex = 0;\n\n    for (let i = 0; i < req.length; i++) {\n      const MPC = await EDDSAMethods.getInitializedMpcInstance();\n      const transaction = req[i].txRequest.transactions[0].unsignedTx;\n      const ovc = req[i].ovc?.[0];\n      const mpcv2SignatureHex = ovc?.eddsaMpcv2Signature;\n      if (!ovc || (!mpcv2SignatureHex && !ovc.eddsaSignature)) {\n        throw new Error('Missing signature(s)');\n      }\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');\n      if (\n        !transaction.coinSpecific ||\n        !transaction.coinSpecific?.firstValid ||\n        !transaction.coinSpecific?.maxDuration\n      ) {\n        throw new Error('missing validity window');\n      }\n      const validityWindow = {\n        firstValid: transaction.coinSpecific?.firstValid,\n        maxDuration: transaction.coinSpecific?.maxDuration,\n      };\n      const material = await this.getMaterial();\n      if (!transaction.coinSpecific?.commonKeychain) {\n        throw new Error('Missing common keychain');\n      }\n      const commonKeychain = transaction.coinSpecific!.commonKeychain! as string;\n      if (!transaction.derivationPath) {\n        throw new Error('Missing derivation path');\n      }\n      const derivationPath = transaction.derivationPath as string;\n      const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);\n      const senderAddr = this.getAddressFromPublicKey(accountId);\n      let signatureHex: Buffer;\n      if (mpcv2SignatureHex) {\n        // MPCv2 (OVC 5-pass): raw 64-byte Ed25519 signature. Verify against the\n        // same derived public key the transaction is signed under, then embed as-is.\n        const signature = Buffer.from(mpcv2SignatureHex, 'hex');\n        const isValid = nacl.sign.detached.verify(messageBuffer, signature, Buffer.from(accountId, 'hex'));\n        if (!isValid) {\n          throw new Error('Invalid signature');\n        }\n        signatureHex = signature;\n      } else {\n        const result = MPC.verify(messageBuffer, ovc.eddsaSignature);\n        if (!result) {\n          throw new Error('Invalid signature');\n        }\n        signatureHex = Buffer.concat([\n          Buffer.from(ovc.eddsaSignature.R, 'hex'),\n          Buffer.from(ovc.eddsaSignature.sigma, 'hex'),\n        ]);\n      }\n      const txnBuilder = this.getBuilder()\n        .material(material)\n        .from(transaction.serializedTx as string)\n        .sender({ address: senderAddr })\n        .validity(validityWindow);\n      const dotKeyPair = new DotKeyPair({ pub: accountId });\n      txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, signatureHex);\n      const signedTransaction = await txnBuilder.build();\n      const serializedTx = signedTransaction.toBroadcastFormat();\n\n      broadcastableTransactions.push({\n        serializedTx: serializedTx,\n        scanIndex: transaction.scanIndex,\n      });\n\n      if (i === req.length - 1 && transaction.coinSpecific!.lastScanIndex) {\n        lastScanIndex = transaction.coinSpecific!.lastScanIndex as number;\n      }\n    }\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n\n  async parseTransaction(params: ParseTransactionOptions): Promise<ParsedTransaction> {\n    return {};\n  }\n\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    return verifyEddsaTssWalletAddress(\n      params,\n      (address) => this.isValidAddress(address),\n      (publicKey) => this.getAddressFromPublicKey(publicKey)\n    );\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    const { txPrebuild, txParams, verification, wallet, reqId } = params;\n    if (!txParams) {\n      throw new Error('missing txParams');\n    }\n\n    if (!txPrebuild) {\n      throw new Error('missing txPrebuild');\n    }\n\n    if (!txPrebuild.txHex) {\n      throw new Error('missing txHex in txPrebuild');\n    }\n\n    const chain = this.getChain();\n    let txTo: string;\n    let txAmount: string;\n    let isSweep: boolean;\n\n    if (chain === 'tdot') {\n      const material = Utils.default.getMaterial(coins.get(chain));\n      const explained = explainDotTransaction({ txHex: txPrebuild.txHex, material });\n      txTo = explained.outputs[0]?.address ?? '';\n      txAmount = String(explained.outputs[0]?.amount ?? '0');\n      isSweep = explained.methodName === 'balances.transferAll';\n    } else {\n      const factory = this.getBuilder();\n      const txBuilder = factory.from(txPrebuild.txHex) as unknown as NativeTransferBuilder;\n      txTo = txBuilder['_to'];\n      txAmount = txBuilder['_amount'];\n      isSweep = txBuilder['_sweepFreeBalance'] === true;\n    }\n\n    if (verification?.consolidationToBaseAddress) {\n      const baseAddress = wallet?.coinSpecific()?.rootAddress || wallet?.coinSpecific()?.baseAddress;\n      if (!baseAddress) {\n        throw new Error('Unable to determine base address for consolidation');\n      }\n      if (txTo !== baseAddress) {\n        throw new TxIntentMismatchRecipientError(\n          `Transaction destination address ${txTo} does not match wallet base address ${baseAddress}`,\n          reqId,\n          [txParams],\n          txPrebuild.txHex,\n          [{ address: txTo, amount: txAmount }]\n        );\n      }\n    }\n\n    if (txParams.recipients !== undefined) {\n      if (txParams.recipients.length === 0) {\n        throw new Error('missing recipients in txParams');\n      }\n\n      if (Array.isArray(txParams.recipients) && txParams.recipients.length > 1) {\n        throw new Error(\n          `${this.getChain()} doesn't support sending to more than 1 destination address within a single transaction. Try again, using only a single recipient.`\n        );\n      }\n\n      if (txParams.recipients[0].address !== txTo) {\n        throw new TxIntentMismatchRecipientError(\n          `Recipient address ${txParams.recipients[0].address} does not match transaction destination address ${txTo}`,\n          reqId,\n          [txParams],\n          txPrebuild.txHex,\n          [{ address: txTo, amount: txAmount }]\n        );\n      }\n\n      if (!isSweep && txParams.recipients[0].amount !== txAmount) {\n        throw new TxIntentMismatchRecipientError(\n          `Recipient amount ${txParams.recipients[0].amount} does not match transaction amount ${txAmount}`,\n          reqId,\n          [txParams],\n          txPrebuild.txHex,\n          [{ address: txTo, amount: txAmount }]\n        );\n      }\n    }\n    return true;\n  }\n\n  getAddressFromPublicKey(Pubkey: string): string {\n    return new DotKeyPair({ pub: Pubkey }).getAddress(Utils.default.getAddressFormat(this.getChain() as DotAssetTypes));\n  }\n\n  private getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  /**\n   * Detects whether a keycard's decrypted plaintext is MPCv1 JSON or MPCv2 CBOR.\n   * Unsigned sweeps (no walletPassphrase) have no keycard to inspect and default to MPCv1.\n   */\n  protected async getEddsaSigningMaterial(userKey: string, walletPassphrase: string): Promise<EddsaSigningMaterial> {\n    return sharedGetEddsaSigningMaterial(userKey.replace(/\\s/g, ''), walletPassphrase, this.bitgo);\n  }\n\n  protected async signDotMpcV2Recovery(params: Parameters<typeof signEddsaMpcV2RecoveryTx>[0]): Promise<Buffer> {\n    return signEddsaMpcV2RecoveryTx(params);\n  }\n\n  /**\n   * Adds an MPCv1 or MPCv2 signature to a DOT transaction builder.\n   *\n   * Transaction#constructSignedPayload already prepends the 0x00 type-tag (the Substrate\n   * MultiSignature enum discriminant for Ed25519) to whatever signature buffer is passed to\n   * addSignature, so both paths here hand off the raw 64-byte signature untouched.\n   */\n  private async addRecoverySignature(\n    signingMaterial: EddsaSigningMaterial,\n    backupKey: string,\n    walletPassphrase: string,\n    txnBuilder: NativeTransferBuilder,\n    accountId: string,\n    unsignedTransaction: Transaction,\n    currPath: string,\n    bitgoKey: string\n  ): Promise<void> {\n    const dotKeyPair = new DotKeyPair({ pub: accountId });\n\n    if (signingMaterial.version === 'v2') {\n      const rawSig = await this.signDotMpcV2Recovery({\n        message: unsignedTransaction.signablePayload,\n        userKey: signingMaterial.encryptedUserKey,\n        backupKey,\n        walletPassphrase,\n        bitgoKey,\n        derivationPath: currPath,\n        bitgo: this.bitgo,\n      });\n      txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, rawSig);\n    } else {\n      /** TODO BG-52419 Implement Codec for parsing */\n      const userSigningMaterial = JSON.parse(signingMaterial.userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n      const backupPrv = await decryptKeychainPrivateKey(this.bitgo, { encryptedPrv: backupKey }, walletPassphrase);\n      if (!backupPrv) {\n        throw new Error('Error decrypting backup keychain: invalid password or corrupted key');\n      }\n      const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;\n\n      const signatureHex = await EDDSAMethods.getTSSSignature(\n        userSigningMaterial,\n        backupSigningMaterial,\n        currPath,\n        unsignedTransaction\n      );\n      txnBuilder.addSignature({ pub: dotKeyPair.getKeys().pub }, signatureHex);\n    }\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ publicKey, prv, multiSigType }: AuditDecryptedKeyParams) {\n    if (multiSigType !== 'tss') {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n}\n"]}