@bitgo-beta/sdk-coin-near 0.0.0-semantic-release-managed

package/dist/src/near.js

@@ -0,0 +1,853 @@
+"use strict";
+/**
+ * @prettier
+ */
+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.Near = void 0;
+const _ = __importStar(require("lodash"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const base58 = __importStar(require("bs58"));
+const nearAPI = __importStar(require("near-api-js"));
+const request = __importStar(require("superagent"));
+const sdk_lib_mpc_1 = require("@bitgo-beta/sdk-lib-mpc");
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const lib_1 = require("./lib");
+const utils_1 = __importDefault(require("./lib/utils"));
+const constants_1 = require("./lib/constants");
+class Near extends sdk_core_1.BaseCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo);
+        this.network = this.bitgo.getEnv() === 'prod' ? 'main' : 'test';
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Near(bitgo, staticsCoin);
+    }
+    allowsAccountConsolidations() {
+        return true;
+    }
+    /**
+     * Flag indicating if this coin supports TSS wallets.
+     * @returns {boolean} True if TSS Wallets can be created for this coin
+     */
+    supportsTss() {
+        return true;
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return sdk_core_1.multisigTypes.tss;
+    }
+    /**
+     * @inheritDoc
+     */
+    getTokenEnablementConfig() {
+        return {
+            requiresTokenEnablement: true,
+            supportsMultipleTokenEnablements: false,
+        };
+    }
+    getMPCAlgorithm() {
+        return 'eddsa';
+    }
+    getChain() {
+        return this._staticsCoin.name;
+    }
+    getBaseChain() {
+        return this.getChain();
+    }
+    getFamily() {
+        return this._staticsCoin.family;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    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 false;
+    }
+    /**
+     * Generate ed25519 key pair
+     *
+     * @param seed
+     * @returns {Object} object with generated pub, prv
+     */
+    generateKeyPair(seed) {
+        const keyPair = seed ? new lib_1.KeyPair({ 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 utils_1.default.isValidPublicKey(pub);
+    }
+    /**
+     * Return boolean indicating whether the supplied private key is a valid near private key
+     *
+     * @param {String} prv the prv to be checked
+     * @returns {Boolean} is it valid?
+     */
+    isValidPrv(prv) {
+        return utils_1.default.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 utils_1.default.isValidAddress(address);
+    }
+    /** @inheritDoc */
+    async signMessage(key, message) {
+        const nearKeypair = new lib_1.KeyPair({ prv: key.prv });
+        if (Buffer.isBuffer(message)) {
+            message = base58.encode(message);
+        }
+        return Buffer.from(nearKeypair.signMessage(message));
+    }
+    /**
+     * Explain/parse transaction
+     * @param params
+     */
+    async explainTransaction(params) {
+        const factory = this.getBuilder();
+        let rebuiltTransaction;
+        const txRaw = params.txPrebuild.txHex;
+        try {
+            const transactionBuilder = factory.from(txRaw);
+            rebuiltTransaction = await transactionBuilder.build();
+        }
+        catch {
+            throw new Error('Invalid transaction');
+        }
+        return rebuiltTransaction.explainTransaction();
+    }
+    verifySignTransactionParams(params) {
+        const prv = params.prv;
+        const txHex = params.txPrebuild.txHex;
+        if (_.isUndefined(txHex)) {
+            throw new Error('missing txPrebuild parameter');
+        }
+        if (!_.isString(txHex)) {
+            throw new Error(`txPrebuild must be an object, got type ${typeof txHex}`);
+        }
+        if (_.isUndefined(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.txPrebuild, 'key')) {
+            throw new Error('missing public key parameter to sign transaction');
+        }
+        // if we are receiving addresses do not try to convert them
+        const signer = !utils_1.default.isValidAddress(params.txPrebuild.key)
+            ? new lib_1.KeyPair({ pub: params.txPrebuild.key }).getAddress()
+            : params.txPrebuild.key;
+        return { txHex, prv, signer };
+    }
+    /**
+     * Assemble keychain and half-sign prebuilt transaction
+     *
+     * @param params
+     * @param params.txPrebuild {TransactionPrebuild} prebuild object returned by platform
+     * @param params.prv {String} user prv
+     * @param callback
+     * @returns {Bluebird<SignedTransaction>}
+     */
+    async signTransaction(params) {
+        const factory = this.getBuilder();
+        const txBuilder = factory.from(params.txPrebuild.txHex);
+        txBuilder.sign({ key: params.prv });
+        const transaction = await txBuilder.build();
+        if (!transaction) {
+            throw new Error('Invalid transaction');
+        }
+        const serializedTx = transaction.toBroadcastFormat();
+        return {
+            txHex: serializedTx,
+        };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param params
+     */
+    async recover(params) {
+        if (!params.bitgoKey) {
+            throw new Error('missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        let startIdx = params.startingScanIndex;
+        if (startIdx === undefined) {
+            startIdx = 0;
+        }
+        else if (!Number.isInteger(startIdx) || startIdx < 0) {
+            throw new Error('Invalid starting index to scan for addresses');
+        }
+        let numIteration = params.scan;
+        if (numIteration === undefined) {
+            numIteration = 20;
+        }
+        else if (!Number.isInteger(numIteration) || numIteration <= 0) {
+            throw new Error('Invalid scanning factor');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;
+        const MPC = await sdk_core_1.EDDSAMethods.getInitializedMpcInstance();
+        const { storageAmountPerByte, transferCost, receiptConfig } = await this.getProtocolConfig();
+        let isStorageDepositEnabled = false;
+        if (params.tokenContractAddress) {
+            // check if receiver storage deposit is enabled
+            isStorageDepositEnabled = await this.checkIfStorageDepositIsEnabled(params.recoveryDestination, params.tokenContractAddress);
+        }
+        for (let i = startIdx; i < numIteration + startIdx; i++) {
+            const currPath = `m/${i}`;
+            const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+            let availableBalance = new bignumber_js_1.default(0);
+            try {
+                availableBalance = new bignumber_js_1.default(await this.getAccountBalance(accountId, storageAmountPerByte));
+            }
+            catch (e) {
+                // UNKNOWN_ACCOUNT error indicates that the address has not partake in any transaction so far, so we will
+                // treat it as a zero balance address
+                if (e.message !== 'UNKNOWN_ACCOUNT') {
+                    throw e;
+                }
+            }
+            if (availableBalance.toNumber() <= 0) {
+                continue;
+            }
+            const feeReserve = (0, bignumber_js_1.default)(statics_1.Networks[this.network].near.feeReserve);
+            const storageReserve = (0, bignumber_js_1.default)(statics_1.Networks[this.network].near.storageReserve);
+            // check for possible token recovery, recover the token provided by the user
+            if (params.tokenContractAddress) {
+                const tokenName = utils_1.default.findTokenNameFromContractAddress(params.tokenContractAddress);
+                if (!tokenName) {
+                    throw new Error(`Token name not found for contract address ${params.tokenContractAddress}. The address may be invalid or unsupported. Please refer to the supported tokens in the BitGo documentation for guidance.`);
+                }
+                const token = utils_1.default.getTokenInstanceFromTokenName(tokenName);
+                if (!token) {
+                    throw new Error(`Token instance could not be created for token name ${tokenName}. The token may be invalid or unsupported. Please refer to the supported tokens in the BitGo documentation for guidance.`);
+                }
+                let availableTokenBalance;
+                try {
+                    availableTokenBalance = new bignumber_js_1.default(await this.getAccountFungibleTokenBalance(accountId, params.tokenContractAddress));
+                }
+                catch (e) {
+                    throw e;
+                }
+                if (availableTokenBalance.toNumber() <= 0) {
+                    continue;
+                }
+                const netAmount = availableBalance
+                    .minus(utils_1.default.convertGasUnitsToYoctoNear(constants_1.MAX_GAS_LIMIT_FOR_FT_TRANSFER))
+                    .minus(feeReserve)
+                    .minus(storageReserve);
+                if (netAmount.toNumber() <= 0) {
+                    throw new Error(`Found address ${i} with non-zero fund but fund is insufficient to support a token recover ` +
+                        `transaction. Please start the next scan at address index ${i + 1}.`);
+                }
+                return this.recoverNearToken(params, token, accountId, currPath, i, bitgoKey, isStorageDepositEnabled, availableTokenBalance, isUnsignedSweep);
+            }
+            // first build the unsigned txn
+            const bs58EncodedPublicKey = nearAPI.utils.serialize.base_encode(new Uint8Array(Buffer.from(accountId, 'hex')));
+            const { nonce, blockHash } = await this.getAccessKey({ accountId, bs58EncodedPublicKey });
+            const gasPrice = await this.getGasPrice(blockHash);
+            const gasPriceFirstBlock = new bignumber_js_1.default(gasPrice);
+            const gasPriceSecondBlock = gasPriceFirstBlock.multipliedBy(1.05);
+            const totalGasRequired = new bignumber_js_1.default(transferCost.sendSir)
+                .plus(receiptConfig.sendSir)
+                .multipliedBy(gasPriceFirstBlock)
+                .plus(new bignumber_js_1.default(transferCost.execution).plus(receiptConfig.execution).multipliedBy(gasPriceSecondBlock));
+            // adding some padding to make sure the gas doesn't go below required gas by network
+            const totalGasWithPadding = totalGasRequired.multipliedBy(1.5);
+            const netAmount = availableBalance.minus(totalGasWithPadding).minus(feeReserve).minus(storageReserve);
+            if (netAmount.toNumber() <= 0) {
+                throw new Error(`Found address ${i} with non-zero fund but fund is insufficient to support a recover ` +
+                    `transaction. Please start the next scan at address index ${i + 1}.`);
+            }
+            const factory = new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getChain()));
+            const txBuilder = factory
+                .getTransferBuilder()
+                .sender(accountId, accountId)
+                .nonce(nonce)
+                .receiverId(params.recoveryDestination)
+                .recentBlockHash(blockHash)
+                .amount(netAmount.toFixed());
+            const unsignedTransaction = (await txBuilder.build());
+            let serializedTx = unsignedTransaction.toBroadcastFormat();
+            if (!isUnsignedSweep) {
+                serializedTx = await this.signRecoveryTransaction(txBuilder, params, currPath, accountId);
+            }
+            else {
+                return this.buildUnsignedSweepTransaction(txBuilder, accountId, params.recoveryDestination, bitgoKey, i, currPath, netAmount, totalGasWithPadding);
+            }
+            return { serializedTx: serializedTx, scanIndex: i };
+        }
+        throw new Error('Did not find an address with funds to recover');
+    }
+    /**
+     * Function to handle near token recovery
+     * @param {MPCRecoveryOptions} params mpc recovery options input
+     * @param {Nep141Token} token the token object
+     * @param {String} senderAddress sender address
+     * @param {String} derivationPath the derivation path
+     * @param {Number} idx current index
+     * @param {String} bitgoKey bitgo key
+     * @param {Boolean} isStorageDepositEnabled flag indicating whether storage deposit is enabled on the receiver
+     * @param {BigNumber} availableTokenBalance currently available token balance on the address
+     * @param {Boolean} isUnsignedSweep flag indicating whether it is an unsigned sweep
+     * @returns {Promise<MPCTx | MPCSweepTxs>}
+     */
+    async recoverNearToken(params, token, senderAddress, derivationPath, idx, bitgoKey, isStorageDepositEnabled, availableTokenBalance, isUnsignedSweep) {
+        const factory = new lib_1.TransactionBuilderFactory(token);
+        const bs58EncodedPublicKey = nearAPI.utils.serialize.base_encode(new Uint8Array(Buffer.from(senderAddress, 'hex')));
+        const { nonce, blockHash } = await this.getAccessKey({ accountId: senderAddress, bs58EncodedPublicKey });
+        const txBuilder = factory
+            .getFungibleTokenTransferBuilder()
+            .sender(senderAddress, senderAddress)
+            .nonce(nonce)
+            .receiverId(token.contractAddress)
+            .recentBlockHash(blockHash)
+            .ftReceiverId(params.recoveryDestination)
+            .gas(constants_1.MAX_GAS_LIMIT_FOR_FT_TRANSFER)
+            .deposit('1')
+            .amount(availableTokenBalance.toString());
+        if (!isStorageDepositEnabled) {
+            txBuilder.addStorageDeposit({
+                deposit: BigInt(token.storageDepositAmount),
+                gas: BigInt(constants_1.MAX_GAS_LIMIT_FOR_FT_TRANSFER),
+                accountId: params.recoveryDestination,
+            });
+        }
+        if (isUnsignedSweep) {
+            return this.buildUnsignedSweepTransaction(txBuilder, senderAddress, params.recoveryDestination, bitgoKey, idx, derivationPath, availableTokenBalance, new bignumber_js_1.default(utils_1.default.convertGasUnitsToYoctoNear(constants_1.MAX_GAS_LIMIT_FOR_FT_TRANSFER)), token);
+        }
+        else {
+            const serializedTx = await this.signRecoveryTransaction(txBuilder, params, derivationPath, senderAddress);
+            return { serializedTx: serializedTx, scanIndex: idx };
+        }
+    }
+    /**
+     * Function to build unsigned sweep transaction
+     * @param {TransactionBuilder} txBuilder the near transaction builder
+     * @param {String} senderAddress sender address
+     * @param {String} receiverAddress the receiver address
+     * @param {String} bitgoKey bitgo key
+     * @param {Number} index current index
+     * @param {String} derivationPath the derivation path
+     * @param {BigNumber} netAmount net amount to be recovered
+     * @param {BigNumber} netGas net gas required
+     * @param {Nep141Token} token optional nep141 token instance
+     * @returns {Promise<MPCSweepTxs>}
+     */
+    async buildUnsignedSweepTransaction(txBuilder, senderAddress, receiverAddress, bitgoKey, index, derivationPath, netAmount, netGas, token) {
+        const isTokenTransaction = !!token;
+        const unsignedTransaction = (await txBuilder.build());
+        const serializedTx = unsignedTransaction.toBroadcastFormat();
+        const walletCoin = isTokenTransaction ? token.name : this.getChain();
+        const inputs = [
+            {
+                address: senderAddress,
+                valueString: netAmount.toString(),
+                value: netAmount.toNumber(),
+            },
+        ];
+        const outputs = [
+            {
+                address: receiverAddress,
+                valueString: netAmount.toString(),
+                coinName: walletCoin,
+            },
+        ];
+        const spendAmount = netAmount.toString();
+        const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+        const feeInfo = { fee: netGas.toNumber(), feeString: netGas.toFixed() }; // Include gas fees
+        const transaction = {
+            serializedTx: serializedTx, // Serialized unsigned transaction
+            scanIndex: index, // Current index in the scan
+            coin: walletCoin,
+            signableHex: unsignedTransaction.signablePayload.toString('hex'), // Hex payload for signing
+            derivationPath: derivationPath, // Derivation path for the account
+            parsedTx: parsedTx,
+            feeInfo: feeInfo,
+            coinSpecific: { commonKeychain: bitgoKey }, // Include block hash for NEAR
+        };
+        const transactions = [{ unsignedTx: transaction, signatureShares: [] }];
+        const txRequest = {
+            transactions: transactions,
+            walletCoin: walletCoin,
+        };
+        return { txRequests: [txRequest] };
+    }
+    /**
+     * Function to sign the recovery transaction
+     * @param {TransactionBuilder} txBuilder the near transaction builder
+     * @param {MPCRecoveryOptions} params mpc recovery options input
+     * @param {String} derivationPath the derivation path
+     * @param {String} senderAddress the sender address
+     * @returns {Promise<String>}
+     */
+    async signRecoveryTransaction(txBuilder, params, derivationPath, senderAddress) {
+        const unsignedTransaction = (await txBuilder.build());
+        // Sign the txn
+        /* ***************** START **************************************/
+        // TODO(BG-51092): This looks like a common part which can be extracted out too
+        if (!params.userKey) {
+            throw new Error('missing userKey');
+        }
+        if (!params.backupKey) {
+            throw new Error('missing backupKey');
+        }
+        if (!params.walletPassphrase) {
+            throw new Error('missing wallet passphrase');
+        }
+        // Clean up whitespace from entered values
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        // Decrypt private keys from KeyCard values
+        let userPrv;
+        try {
+            userPrv = this.bitgo.decrypt({
+                input: userKey,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting user keychain: ${e.message}`);
+        }
+        /** TODO BG-52419 Implement Codec for parsing */
+        const userSigningMaterial = JSON.parse(userPrv);
+        let backupPrv;
+        try {
+            backupPrv = this.bitgo.decrypt({
+                input: backupKey,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting backup keychain: ${e.message}`);
+        }
+        const backupSigningMaterial = JSON.parse(backupPrv);
+        /* ********************** END ***********************************/
+        // add signature
+        const signatureHex = await sdk_core_1.EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, derivationPath, unsignedTransaction);
+        const publicKeyObj = { pub: senderAddress };
+        txBuilder.addSignature(publicKeyObj, signatureHex);
+        const completedTransaction = await txBuilder.build();
+        return completedTransaction.toBroadcastFormat();
+    }
+    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;
+            // Validate signature shares
+            if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {
+                throw new Error('Missing signature(s)');
+            }
+            const signature = req[i].ovc[0].eddsaSignature;
+            // Validate signable hex
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const messageBuffer = Buffer.from(transaction.signableHex, 'hex');
+            const result = MPC.verify(messageBuffer, signature);
+            if (!result) {
+                throw new Error('Invalid signature');
+            }
+            // Prepare the signature in hex format
+            const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);
+            // Validate transaction-specific fields
+            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;
+            // Derive account ID and sender address
+            const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);
+            const txnBuilder = this.getBuilder().from(transaction.serializedTx);
+            // Add the signature
+            const nearKeyPair = new lib_1.KeyPair({ pub: accountId });
+            txnBuilder.addSignature({ pub: nearKeyPair.getKeys().pub }, signatureHex);
+            // Finalize and serialize the transaction
+            const signedTransaction = await txnBuilder.build();
+            const serializedTx = signedTransaction.toBroadcastFormat();
+            // Add the signed transaction to the list
+            broadcastableTransactions.push({
+                serializedTx: serializedTx,
+                scanIndex: transaction.scanIndex,
+            });
+            // Update the last scan index if applicable
+            if (i === req.length - 1 && transaction.coinSpecific.lastScanIndex) {
+                lastScanIndex = transaction.coinSpecific.lastScanIndex;
+            }
+        }
+        // Return the broadcastable transactions and the last scan index
+        return { transactions: broadcastableTransactions, lastScanIndex };
+    }
+    /**
+     * Make a request to one of the public EOS nodes available
+     * @param params.payload
+     */
+    async getDataFromNode(params) {
+        const nodeUrls = this.getPublicNodeUrls();
+        for (const nodeUrl of nodeUrls) {
+            try {
+                return await request.post(nodeUrl).send(params.payload);
+            }
+            catch (e) {
+                console.debug(e);
+            }
+        }
+        throw new Error(`Unable to call endpoint: '/' from nodes: ${_.join(nodeUrls, ', ')}`);
+    }
+    async getAccessKey({ accountId, bs58EncodedPublicKey, }) {
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'query',
+                params: {
+                    request_type: 'view_access_key',
+                    finality: 'final',
+                    account_id: accountId,
+                    public_key: bs58EncodedPublicKey,
+                },
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        const accessKey = response.body.result;
+        return { nonce: accessKey.nonce + 1, blockHash: accessKey.block_hash };
+    }
+    async getAccountBalance(accountId, storageAmountPerByte) {
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'query',
+                params: {
+                    request_type: 'view_account',
+                    finality: 'final',
+                    account_id: accountId,
+                },
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Failed to query account information');
+        }
+        const errorCause = response.body.error?.cause.name;
+        if (errorCause !== undefined) {
+            throw new Error(errorCause);
+        }
+        const account = response.body.result;
+        const costPerByte = new bignumber_js_1.default(storageAmountPerByte);
+        const stateStaked = new bignumber_js_1.default(account.storage_usage).multipliedBy(costPerByte);
+        const staked = new bignumber_js_1.default(account.locked);
+        const totalBalance = new bignumber_js_1.default(account.amount).plus(staked);
+        const availableBalance = totalBalance.minus(bignumber_js_1.default.max(staked, stateStaked));
+        return availableBalance.toString();
+    }
+    /**
+     * Function to get the fungible token balance for an account
+     * @param {String} accountId account for which the ft balance to be fetched
+     * @param tokenContractAddress the token contract address
+     * @returns {Promise<String>}
+     */
+    async getAccountFungibleTokenBalance(accountId, tokenContractAddress) {
+        const base64Args = utils_1.default.convertToBase64({ account_id: accountId });
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'query',
+                params: {
+                    request_type: 'call_function',
+                    finality: 'final',
+                    account_id: tokenContractAddress,
+                    method_name: 'ft_balance_of',
+                    args_base64: base64Args,
+                },
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Failed to fetch ft balance of the account');
+        }
+        const errorCause = response.body.error?.cause?.name;
+        if (errorCause !== undefined) {
+            throw new Error(errorCause);
+        }
+        const resultUint8Array = new Uint8Array(response.body.result.result);
+        const raw = new TextDecoder().decode(resultUint8Array);
+        return JSON.parse(raw);
+    }
+    /**
+     * Function to check if storage deposit is enabled on an address for a token
+     * @param {String} accountId account for which the storage balance to be fetched
+     * @param tokenContractAddress the token contract address
+     * @returns {Promise<Boolean>} true if we find the storage balance, false if response is null
+     */
+    async checkIfStorageDepositIsEnabled(accountId, tokenContractAddress) {
+        const base64Args = utils_1.default.convertToBase64({ account_id: accountId });
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'query',
+                params: {
+                    request_type: 'call_function',
+                    finality: 'final',
+                    account_id: tokenContractAddress,
+                    method_name: 'storage_balance_of',
+                    args_base64: base64Args,
+                },
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Failed to fetch storage deposit of the account');
+        }
+        const errorCause = response.body.error?.cause?.name;
+        if (errorCause !== undefined) {
+            throw new Error(errorCause);
+        }
+        const resultUint8Array = new Uint8Array(response.body.result.result);
+        const raw = new TextDecoder().decode(resultUint8Array);
+        const decoded = JSON.parse(raw);
+        return decoded !== null;
+    }
+    async getProtocolConfig() {
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'EXPERIMENTAL_protocol_config',
+                params: {
+                    finality: 'final',
+                },
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        const config = response.body.result;
+        const storageAmountPerByte = config.runtime_config.storage_amount_per_byte;
+        const transferCostFromNetwork = config.runtime_config.transaction_costs.action_creation_config.transfer_cost;
+        const transferCost = {
+            sendSir: transferCostFromNetwork.send_sir,
+            sendNotSir: transferCostFromNetwork.send_not_sir,
+            execution: transferCostFromNetwork.execution,
+        };
+        const receiptConfigFromNetwork = config.runtime_config.transaction_costs.action_receipt_creation_config;
+        const receiptConfig = {
+            sendSir: receiptConfigFromNetwork.send_sir,
+            sendNotSir: receiptConfigFromNetwork.send_not_sir,
+            execution: receiptConfigFromNetwork.execution,
+        };
+        return { storageAmountPerByte, transferCost, receiptConfig };
+    }
+    async getGasPrice(blockHash) {
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: 'dontcare',
+                method: 'gas_price',
+                params: [blockHash],
+            },
+        });
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return response.body.result.gas_price;
+    }
+    getPublicNodeUrls() {
+        return sdk_core_1.Environments[this.bitgo.getEnv()].nearNodeUrls;
+    }
+    async parseTransaction(params) {
+        const transactionExplanation = await this.explainTransaction({
+            txPrebuild: params.txPrebuild,
+            publicKey: params.publicKey,
+            feeInfo: params.feeInfo,
+        });
+        if (!transactionExplanation) {
+            throw new Error('Invalid transaction');
+        }
+        const nearTransaction = transactionExplanation;
+        if (nearTransaction.outputs.length <= 0) {
+            return {
+                inputs: [],
+                outputs: [],
+            };
+        }
+        const senderAddress = nearTransaction.outputs[0].address;
+        const feeAmount = new bignumber_js_1.default(nearTransaction.fee.fee === '' ? '0' : nearTransaction.fee.fee);
+        // assume 1 sender, who is also the fee payer
+        const inputs = [
+            {
+                address: senderAddress,
+                amount: new bignumber_js_1.default(nearTransaction.outputAmount).plus(feeAmount).toFixed(),
+            },
+        ];
+        const outputs = nearTransaction.outputs.map((output) => {
+            return {
+                address: output.address,
+                amount: new bignumber_js_1.default(output.amount).toFixed(),
+            };
+        });
+        return {
+            inputs,
+            outputs,
+        };
+    }
+    async isWalletAddress(params) {
+        throw new sdk_core_1.MethodNotImplementedError();
+    }
+    async verifyTransaction(params) {
+        let totalAmount = new bignumber_js_1.default(0);
+        const coinConfig = statics_1.coins.get(this.getChain());
+        const { txPrebuild: txPrebuild, txParams: txParams } = params;
+        const transaction = new lib_1.Transaction(coinConfig);
+        const rawTx = txPrebuild.txHex;
+        if (!rawTx) {
+            throw new Error('missing required tx prebuild property txHex');
+        }
+        transaction.fromRawTransaction(rawTx);
+        const explainedTx = transaction.explainTransaction();
+        // users do not input recipients for consolidation requests as they are generated by the server
+        if (txParams.recipients !== undefined) {
+            if (txParams.type === 'enabletoken') {
+                const tokenName = explainedTx.outputs[0].tokenName;
+                if (tokenName) {
+                    const nepToken = utils_1.default.getTokenInstanceFromTokenName(tokenName);
+                    if (nepToken) {
+                        explainedTx.outputs.forEach((output) => {
+                            if (output.amount !== nepToken.storageDepositAmount) {
+                                throw new Error('Storage deposit amount not matching!');
+                            }
+                        });
+                    }
+                }
+            }
+            const filteredRecipients = txParams.recipients?.map((recipient) => {
+                if (txParams.type !== 'enabletoken') {
+                    return _.pick(recipient, ['address', 'amount']);
+                }
+                else {
+                    return _.pick(recipient, ['address', 'tokenName']);
+                }
+            });
+            const filteredOutputs = explainedTx.outputs.map((output) => {
+                if (txParams.type !== 'enabletoken') {
+                    return _.pick(output, ['address', 'amount']);
+                }
+                else {
+                    return _.pick(output, ['address', 'tokenName']);
+                }
+            });
+            if (!_.isEqual(filteredOutputs, filteredRecipients)) {
+                throw new Error('Tx outputs does not match with expected txParams recipients');
+            }
+            for (const recipients of txParams.recipients) {
+                totalAmount = txParams.type !== 'enabletoken' ? totalAmount.plus(recipients.amount) : (0, bignumber_js_1.default)(0);
+            }
+            if (!totalAmount.isEqualTo(explainedTx.outputAmount) && txParams.type !== 'enabletoken') {
+                throw new Error('Tx total amount does not match with expected total amount field');
+            }
+        }
+        if (params.verification?.consolidationToBaseAddress) {
+            await this.verifyConsolidationToBaseAddress(params, explainedTx);
+        }
+        return true;
+    }
+    getBuilder() {
+        return new lib_1.TransactionBuilderFactory(statics_1.coins.get(this.getBaseChain()));
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ prv, publicKey, multiSigType }) {
+        if (multiSigType !== 'tss') {
+            throw new Error('Unsupported multiSigType');
+        }
+        (0, sdk_lib_mpc_1.auditEddsaPrivateKey)(prv, publicKey ?? '');
+    }
+    async verifyConsolidationToBaseAddress(params, explainedTx) {
+        const baseAddresses = await params.wallet.addresses({ sort: -1, limit: 1 });
+        if (!baseAddresses || baseAddresses.length === 0) {
+            throw new Error('No base address found on wallet');
+        }
+        const baseAddress = baseAddresses[0];
+        for (const output of explainedTx.outputs) {
+            if (output.address !== baseAddress.address) {
+                throw new Error('tx outputs does not match with expected address');
+            }
+        }
+    }
+}
+exports.Near = Near;
+Near.initialized = false;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"near.js","sourceRoot":"","sources":["../../src/near.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\n\nimport * as _ from 'lodash';\nimport BigNumber from 'bignumber.js';\nimport * as base58 from 'bs58';\nimport * as nearAPI from 'near-api-js';\nimport * as request from 'superagent';\n\nimport { auditEddsaPrivateKey } from '@bitgo-beta/sdk-lib-mpc';\nimport {\n  AuditDecryptedKeyParams,\n  BaseAddress,\n  BaseCoin,\n  BaseTransaction,\n  BitGoBase,\n  Eddsa,\n  EDDSAMethods,\n  EDDSAMethodTypes,\n  Environments,\n  KeyPair,\n  MethodNotImplementedError,\n  MPCAlgorithm,\n  MPCRecoveryOptions,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  MPCUnsignedTx,\n  MultisigType,\n  multisigTypes,\n  ParsedTransaction,\n  ParseTransactionOptions as BaseParseTransactionOptions,\n  PublicKey,\n  RecoveryTxRequest,\n  SignedTransaction,\n  SignTransactionOptions as BaseSignTransactionOptions,\n  TokenEnablementConfig,\n  TransactionExplanation,\n  VerifyAddressOptions,\n  VerifyTransactionOptions,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin as StaticsBaseCoin, CoinFamily, coins, Nep141Token, Networks } from '@bitgo-beta/statics';\n\nimport { KeyPair as NearKeyPair, Transaction, TransactionBuilder, TransactionBuilderFactory } from './lib';\nimport nearUtils from './lib/utils';\nimport { MAX_GAS_LIMIT_FOR_FT_TRANSFER } from './lib/constants';\n\nexport interface SignTransactionOptions extends BaseSignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string;\n}\n\nexport interface TransactionPrebuild {\n  txHex: string;\n  key: string;\n  blockHash: string;\n  nonce: bigint;\n}\n\nexport interface ExplainTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  publicKey: string;\n  feeInfo: {\n    fee: string;\n  };\n}\n\nexport interface VerifiedTransactionParameters {\n  txHex: string;\n  prv: string;\n  signer: string;\n}\n\nexport interface NearParseTransactionOptions extends BaseParseTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  publicKey: string;\n  feeInfo: {\n    fee: string;\n  };\n}\n\ninterface TransactionOutput {\n  address: string;\n  amount: string;\n}\n\ninterface NearTxBuilderParamsFromNode {\n  nonce: bigint;\n  blockHash: string;\n}\n\ninterface NearFeeConfig {\n  sendSir: number;\n  sendNotSir: number;\n  execution: number;\n}\n\ninterface ProtocolConfigOutput {\n  storageAmountPerByte: number;\n  transferCost: NearFeeConfig;\n  receiptConfig: NearFeeConfig;\n}\n\ntype TransactionInput = TransactionOutput;\n\nexport interface NearParsedTransaction extends ParsedTransaction {\n  // total assets being moved, including fees\n  inputs: TransactionInput[];\n\n  // where assets are moved to\n  outputs: TransactionOutput[];\n}\n\nexport type NearTransactionExplanation = TransactionExplanation;\n\nexport class Near extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\n\n  constructor(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>) {\n    super(bitgo);\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 network = this.bitgo.getEnv() === 'prod' ? 'main' : 'test';\n\n  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Near(bitgo, staticsCoin);\n  }\n\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  /**\n   * Flag indicating if this coin supports TSS wallets.\n   * @returns {boolean} True if TSS Wallets can be created for this coin\n   */\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** inherited doc */\n  getDefaultMultisigType(): MultisigType {\n    return multisigTypes.tss;\n  }\n\n  /**\n   * @inheritDoc\n   */\n  getTokenEnablementConfig(): TokenEnablementConfig {\n    return {\n      requiresTokenEnablement: true,\n      supportsMultipleTokenEnablements: false,\n    };\n  }\n\n  getMPCAlgorithm(): MPCAlgorithm {\n    return 'eddsa';\n  }\n\n  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getBaseChain(): string {\n    return this.getChain();\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  getBaseFactor(): any {\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 false;\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 ? new NearKeyPair({ seed }) : new NearKeyPair();\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 nearUtils.isValidPublicKey(pub);\n  }\n\n  /**\n   * Return boolean indicating whether the supplied private key is a valid near 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 nearUtils.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 nearUtils.isValidAddress(address);\n  }\n\n  /** @inheritDoc */\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const nearKeypair = new NearKeyPair({ prv: key.prv });\n    if (Buffer.isBuffer(message)) {\n      message = base58.encode(message);\n    }\n\n    return Buffer.from(nearKeypair.signMessage(message));\n  }\n\n  /**\n   * Explain/parse transaction\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<NearTransactionExplanation> {\n    const factory = this.getBuilder();\n    let rebuiltTransaction: BaseTransaction;\n    const txRaw = params.txPrebuild.txHex;\n\n    try {\n      const transactionBuilder = factory.from(txRaw);\n      rebuiltTransaction = await transactionBuilder.build();\n    } catch {\n      throw new Error('Invalid transaction');\n    }\n\n    return rebuiltTransaction.explainTransaction();\n  }\n\n  verifySignTransactionParams(params: SignTransactionOptions): VerifiedTransactionParameters {\n    const prv = params.prv;\n\n    const txHex = params.txPrebuild.txHex;\n\n    if (_.isUndefined(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 (_.isUndefined(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.txPrebuild, 'key')) {\n      throw new Error('missing public key parameter to sign transaction');\n    }\n\n    // if we are receiving addresses do not try to convert them\n    const signer = !nearUtils.isValidAddress(params.txPrebuild.key)\n      ? new NearKeyPair({ pub: params.txPrebuild.key }).getAddress()\n      : params.txPrebuild.key;\n    return { txHex, prv, signer };\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   * @param callback\n   * @returns {Bluebird<SignedTransaction>}\n   */\n  async signTransaction(params: SignTransactionOptions): Promise<SignedTransaction> {\n    const factory = this.getBuilder();\n    const txBuilder = factory.from(params.txPrebuild.txHex);\n    txBuilder.sign({ key: params.prv });\n    const transaction: BaseTransaction = await txBuilder.build();\n\n    if (!transaction) {\n      throw new Error('Invalid transaction');\n    }\n\n    const serializedTx = (transaction as BaseTransaction).toBroadcastFormat();\n\n    return {\n      txHex: serializedTx,\n    } as any;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param params\n   */\n  async recover(params: MPCRecoveryOptions): 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    let startIdx = params.startingScanIndex;\n    if (startIdx === undefined) {\n      startIdx = 0;\n    } else if (!Number.isInteger(startIdx) || startIdx < 0) {\n      throw new Error('Invalid starting index to scan for addresses');\n    }\n    let numIteration = params.scan;\n    if (numIteration === undefined) {\n      numIteration = 20;\n    } else if (!Number.isInteger(numIteration) || numIteration <= 0) {\n      throw new Error('Invalid scanning factor');\n    }\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const isUnsignedSweep = !params.userKey && !params.backupKey && !params.walletPassphrase;\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    const { storageAmountPerByte, transferCost, receiptConfig } = await this.getProtocolConfig();\n    let isStorageDepositEnabled = false;\n\n    if (params.tokenContractAddress) {\n      // check if receiver storage deposit is enabled\n      isStorageDepositEnabled = await this.checkIfStorageDepositIsEnabled(\n        params.recoveryDestination,\n        params.tokenContractAddress\n      );\n    }\n\n    for (let i = startIdx; i < numIteration + startIdx; i++) {\n      const currPath = `m/${i}`;\n      const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);\n      let availableBalance = new BigNumber(0);\n      try {\n        availableBalance = new BigNumber(await this.getAccountBalance(accountId, storageAmountPerByte));\n      } catch (e) {\n        // UNKNOWN_ACCOUNT error indicates that the address has not partake in any transaction so far, so we will\n        // treat it as a zero balance address\n        if (e.message !== 'UNKNOWN_ACCOUNT') {\n          throw e;\n        }\n      }\n      if (availableBalance.toNumber() <= 0) {\n        continue;\n      }\n      const feeReserve = BigNumber(Networks[this.network].near.feeReserve);\n      const storageReserve = BigNumber(Networks[this.network].near.storageReserve);\n\n      // check for possible token recovery, recover the token provided by the user\n      if (params.tokenContractAddress) {\n        const tokenName = nearUtils.findTokenNameFromContractAddress(params.tokenContractAddress);\n        if (!tokenName) {\n          throw new Error(\n            `Token name not found for contract address ${params.tokenContractAddress}. The address may be invalid or unsupported. Please refer to the supported tokens in the BitGo documentation for guidance.`\n          );\n        }\n        const token = nearUtils.getTokenInstanceFromTokenName(tokenName);\n        if (!token) {\n          throw new Error(\n            `Token instance could not be created for token name ${tokenName}. The token may be invalid or unsupported. Please refer to the supported tokens in the BitGo documentation for guidance.`\n          );\n        }\n        let availableTokenBalance: BigNumber;\n        try {\n          availableTokenBalance = new BigNumber(\n            await this.getAccountFungibleTokenBalance(accountId, params.tokenContractAddress)\n          );\n        } catch (e) {\n          throw e;\n        }\n        if (availableTokenBalance.toNumber() <= 0) {\n          continue;\n        }\n        const netAmount = availableBalance\n          .minus(nearUtils.convertGasUnitsToYoctoNear(MAX_GAS_LIMIT_FOR_FT_TRANSFER))\n          .minus(feeReserve)\n          .minus(storageReserve);\n        if (netAmount.toNumber() <= 0) {\n          throw new Error(\n            `Found address ${i} with non-zero fund but fund is insufficient to support a token recover ` +\n              `transaction. Please start the next scan at address index ${i + 1}.`\n          );\n        }\n        return this.recoverNearToken(\n          params,\n          token,\n          accountId,\n          currPath,\n          i,\n          bitgoKey,\n          isStorageDepositEnabled,\n          availableTokenBalance,\n          isUnsignedSweep\n        );\n      }\n\n      // first build the unsigned txn\n      const bs58EncodedPublicKey = nearAPI.utils.serialize.base_encode(new Uint8Array(Buffer.from(accountId, 'hex')));\n      const { nonce, blockHash } = await this.getAccessKey({ accountId, bs58EncodedPublicKey });\n      const gasPrice = await this.getGasPrice(blockHash);\n      const gasPriceFirstBlock = new BigNumber(gasPrice);\n      const gasPriceSecondBlock = gasPriceFirstBlock.multipliedBy(1.05);\n      const totalGasRequired = new BigNumber(transferCost.sendSir)\n        .plus(receiptConfig.sendSir)\n        .multipliedBy(gasPriceFirstBlock)\n        .plus(new BigNumber(transferCost.execution).plus(receiptConfig.execution).multipliedBy(gasPriceSecondBlock));\n      // adding some padding to make sure the gas doesn't go below required gas by network\n      const totalGasWithPadding = totalGasRequired.multipliedBy(1.5);\n      const netAmount = availableBalance.minus(totalGasWithPadding).minus(feeReserve).minus(storageReserve);\n      if (netAmount.toNumber() <= 0) {\n        throw new Error(\n          `Found address ${i} with non-zero fund but fund is insufficient to support a recover ` +\n            `transaction. Please start the next scan at address index ${i + 1}.`\n        );\n      }\n      const factory = new TransactionBuilderFactory(coins.get(this.getChain()));\n      const txBuilder = factory\n        .getTransferBuilder()\n        .sender(accountId, accountId)\n        .nonce(nonce)\n        .receiverId(params.recoveryDestination)\n        .recentBlockHash(blockHash)\n        .amount(netAmount.toFixed());\n      const unsignedTransaction = (await txBuilder.build()) as Transaction;\n      let serializedTx = unsignedTransaction.toBroadcastFormat();\n      if (!isUnsignedSweep) {\n        serializedTx = await this.signRecoveryTransaction(txBuilder, params, currPath, accountId);\n      } else {\n        return this.buildUnsignedSweepTransaction(\n          txBuilder,\n          accountId,\n          params.recoveryDestination,\n          bitgoKey,\n          i,\n          currPath,\n          netAmount,\n          totalGasWithPadding\n        );\n      }\n      return { serializedTx: serializedTx, scanIndex: i };\n    }\n    throw new Error('Did not find an address with funds to recover');\n  }\n\n  /**\n   * Function to handle near token recovery\n   * @param {MPCRecoveryOptions} params mpc recovery options input\n   * @param {Nep141Token} token the token object\n   * @param {String} senderAddress sender address\n   * @param {String} derivationPath the derivation path\n   * @param {Number} idx current index\n   * @param {String} bitgoKey bitgo key\n   * @param {Boolean} isStorageDepositEnabled flag indicating whether storage deposit is enabled on the receiver\n   * @param {BigNumber} availableTokenBalance currently available token balance on the address\n   * @param {Boolean} isUnsignedSweep flag indicating whether it is an unsigned sweep\n   * @returns {Promise<MPCTx | MPCSweepTxs>}\n   */\n  private async recoverNearToken(\n    params: MPCRecoveryOptions,\n    token: Nep141Token,\n    senderAddress: string,\n    derivationPath: string,\n    idx: number,\n    bitgoKey: string,\n    isStorageDepositEnabled: boolean,\n    availableTokenBalance: BigNumber,\n    isUnsignedSweep: boolean\n  ): Promise<MPCTx | MPCSweepTxs> {\n    const factory = new TransactionBuilderFactory(token);\n    const bs58EncodedPublicKey = nearAPI.utils.serialize.base_encode(new Uint8Array(Buffer.from(senderAddress, 'hex')));\n    const { nonce, blockHash } = await this.getAccessKey({ accountId: senderAddress, bs58EncodedPublicKey });\n    const txBuilder = factory\n      .getFungibleTokenTransferBuilder()\n      .sender(senderAddress, senderAddress)\n      .nonce(nonce)\n      .receiverId(token.contractAddress)\n      .recentBlockHash(blockHash)\n      .ftReceiverId(params.recoveryDestination)\n      .gas(MAX_GAS_LIMIT_FOR_FT_TRANSFER)\n      .deposit('1')\n      .amount(availableTokenBalance.toString());\n    if (!isStorageDepositEnabled) {\n      txBuilder.addStorageDeposit({\n        deposit: BigInt(token.storageDepositAmount),\n        gas: BigInt(MAX_GAS_LIMIT_FOR_FT_TRANSFER),\n        accountId: params.recoveryDestination,\n      });\n    }\n    if (isUnsignedSweep) {\n      return this.buildUnsignedSweepTransaction(\n        txBuilder,\n        senderAddress,\n        params.recoveryDestination,\n        bitgoKey,\n        idx,\n        derivationPath,\n        availableTokenBalance,\n        new BigNumber(nearUtils.convertGasUnitsToYoctoNear(MAX_GAS_LIMIT_FOR_FT_TRANSFER)),\n        token\n      );\n    } else {\n      const serializedTx = await this.signRecoveryTransaction(txBuilder, params, derivationPath, senderAddress);\n      return { serializedTx: serializedTx, scanIndex: idx };\n    }\n  }\n\n  /**\n   * Function to build unsigned sweep transaction\n   * @param {TransactionBuilder} txBuilder the near transaction builder\n   * @param {String} senderAddress sender address\n   * @param {String} receiverAddress the receiver address\n   * @param {String} bitgoKey bitgo key\n   * @param {Number} index current index\n   * @param {String} derivationPath the derivation path\n   * @param {BigNumber} netAmount net amount to be recovered\n   * @param {BigNumber} netGas net gas required\n   * @param {Nep141Token} token optional nep141 token instance\n   * @returns {Promise<MPCSweepTxs>}\n   */\n  private async buildUnsignedSweepTransaction(\n    txBuilder: TransactionBuilder,\n    senderAddress: string,\n    receiverAddress: string,\n    bitgoKey: string,\n    index: number,\n    derivationPath: string,\n    netAmount: BigNumber,\n    netGas: BigNumber,\n    token?: Nep141Token\n  ): Promise<MPCSweepTxs> {\n    const isTokenTransaction = !!token;\n    const unsignedTransaction = (await txBuilder.build()) as Transaction;\n    const serializedTx = unsignedTransaction.toBroadcastFormat();\n    const walletCoin = isTokenTransaction ? token.name : this.getChain();\n    const inputs = [\n      {\n        address: senderAddress,\n        valueString: netAmount.toString(),\n        value: netAmount.toNumber(),\n      },\n    ];\n    const outputs = [\n      {\n        address: receiverAddress,\n        valueString: netAmount.toString(),\n        coinName: walletCoin,\n      },\n    ];\n    const spendAmount = netAmount.toString();\n    const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };\n    const feeInfo = { fee: netGas.toNumber(), feeString: netGas.toFixed() }; // Include gas fees\n\n    const transaction: MPCTx = {\n      serializedTx: serializedTx, // Serialized unsigned transaction\n      scanIndex: index, // Current index in the scan\n      coin: walletCoin,\n      signableHex: unsignedTransaction.signablePayload.toString('hex'), // Hex payload for signing\n      derivationPath: derivationPath, // Derivation path for the account\n      parsedTx: parsedTx,\n      feeInfo: feeInfo,\n      coinSpecific: { commonKeychain: bitgoKey }, // Include block hash for NEAR\n    };\n\n    const transactions: MPCUnsignedTx[] = [{ unsignedTx: transaction, signatureShares: [] }];\n    const txRequest: RecoveryTxRequest = {\n      transactions: transactions,\n      walletCoin: walletCoin,\n    };\n    return { txRequests: [txRequest] };\n  }\n\n  /**\n   * Function to sign the recovery transaction\n   * @param {TransactionBuilder} txBuilder the near transaction builder\n   * @param {MPCRecoveryOptions} params mpc recovery options input\n   * @param {String} derivationPath the derivation path\n   * @param {String} senderAddress the sender address\n   * @returns {Promise<String>}\n   */\n  private async signRecoveryTransaction(\n    txBuilder: TransactionBuilder,\n    params: MPCRecoveryOptions,\n    derivationPath: string,\n    senderAddress: string\n  ): Promise<string> {\n    const unsignedTransaction = (await txBuilder.build()) as Transaction;\n    // Sign the txn\n    /* ***************** START **************************************/\n    // TODO(BG-51092): This looks like a common part which can be extracted out too\n    if (!params.userKey) {\n      throw new Error('missing userKey');\n    }\n    if (!params.backupKey) {\n      throw new Error('missing backupKey');\n    }\n    if (!params.walletPassphrase) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    // Clean up whitespace from entered values\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    // Decrypt private keys from KeyCard values\n    let userPrv;\n    try {\n      userPrv = this.bitgo.decrypt({\n        input: userKey,\n        password: params.walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting user keychain: ${e.message}`);\n    }\n    /** TODO BG-52419 Implement Codec for parsing */\n    const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n    let backupPrv;\n    try {\n      backupPrv = this.bitgo.decrypt({\n        input: backupKey,\n        password: params.walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting backup keychain: ${e.message}`);\n    }\n    const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;\n    /* ********************** END ***********************************/\n\n    // add signature\n    const signatureHex = await EDDSAMethods.getTSSSignature(\n      userSigningMaterial,\n      backupSigningMaterial,\n      derivationPath,\n      unsignedTransaction\n    );\n    const publicKeyObj = { pub: senderAddress };\n    txBuilder.addSignature(publicKeyObj as PublicKey, signatureHex);\n\n    const completedTransaction = await txBuilder.build();\n    return completedTransaction.toBroadcastFormat();\n  }\n\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\n      // Validate signature shares\n      if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {\n        throw new Error('Missing signature(s)');\n      }\n      const signature = req[i].ovc[0].eddsaSignature;\n\n      // Validate signable hex\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');\n      const result = MPC.verify(messageBuffer, signature);\n      if (!result) {\n        throw new Error('Invalid signature');\n      }\n\n      // Prepare the signature in hex format\n      const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);\n\n      // Validate transaction-specific fields\n      if (!transaction.coinSpecific?.commonKeychain) {\n        throw new Error('Missing common keychain');\n      }\n      const commonKeychain = transaction.coinSpecific!.commonKeychain! as string;\n\n      if (!transaction.derivationPath) {\n        throw new Error('Missing derivation path');\n      }\n      const derivationPath = transaction.derivationPath as string;\n\n      // Derive account ID and sender address\n      const accountId = MPC.deriveUnhardened(commonKeychain, derivationPath).slice(0, 64);\n      const txnBuilder = this.getBuilder().from(transaction.serializedTx as string);\n\n      // Add the signature\n      const nearKeyPair = new NearKeyPair({ pub: accountId });\n      txnBuilder.addSignature({ pub: nearKeyPair.getKeys().pub }, signatureHex);\n\n      // Finalize and serialize the transaction\n      const signedTransaction = await txnBuilder.build();\n      const serializedTx = signedTransaction.toBroadcastFormat();\n\n      // Add the signed transaction to the list\n      broadcastableTransactions.push({\n        serializedTx: serializedTx,\n        scanIndex: transaction.scanIndex,\n      });\n\n      // Update the last scan index if applicable\n      if (i === req.length - 1 && transaction.coinSpecific!.lastScanIndex) {\n        lastScanIndex = transaction.coinSpecific!.lastScanIndex as number;\n      }\n    }\n\n    // Return the broadcastable transactions and the last scan index\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n\n  /**\n   * Make a request to one of the public EOS nodes available\n   * @param params.payload\n   */\n  protected async getDataFromNode(params: { payload?: Record<string, unknown> }): Promise<request.Response> {\n    const nodeUrls = this.getPublicNodeUrls();\n    for (const nodeUrl of nodeUrls) {\n      try {\n        return await request.post(nodeUrl).send(params.payload);\n      } catch (e) {\n        console.debug(e);\n      }\n    }\n    throw new Error(`Unable to call endpoint: '/' from nodes: ${_.join(nodeUrls, ', ')}`);\n  }\n\n  protected async getAccessKey({\n    accountId,\n    bs58EncodedPublicKey,\n  }: {\n    accountId: string;\n    bs58EncodedPublicKey: string;\n  }): Promise<NearTxBuilderParamsFromNode> {\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'query',\n        params: {\n          request_type: 'view_access_key',\n          finality: 'final',\n          account_id: accountId,\n          public_key: bs58EncodedPublicKey,\n        },\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    const accessKey = response.body.result;\n    return { nonce: accessKey.nonce + 1, blockHash: accessKey.block_hash };\n  }\n\n  protected async getAccountBalance(accountId: string, storageAmountPerByte: number): Promise<string> {\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'query',\n        params: {\n          request_type: 'view_account',\n          finality: 'final',\n          account_id: accountId,\n        },\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Failed to query account information');\n    }\n    const errorCause = response.body.error?.cause.name;\n    if (errorCause !== undefined) {\n      throw new Error(errorCause);\n    }\n\n    const account = response.body.result;\n    const costPerByte = new BigNumber(storageAmountPerByte);\n    const stateStaked = new BigNumber(account.storage_usage).multipliedBy(costPerByte);\n    const staked = new BigNumber(account.locked);\n    const totalBalance = new BigNumber(account.amount).plus(staked);\n    const availableBalance = totalBalance.minus(BigNumber.max(staked, stateStaked));\n    return availableBalance.toString();\n  }\n\n  /**\n   * Function to get the fungible token balance for an account\n   * @param {String} accountId account for which the ft balance to be fetched\n   * @param tokenContractAddress the token contract address\n   * @returns {Promise<String>}\n   */\n  protected async getAccountFungibleTokenBalance(accountId: string, tokenContractAddress: string): Promise<string> {\n    const base64Args = nearUtils.convertToBase64({ account_id: accountId });\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'query',\n        params: {\n          request_type: 'call_function',\n          finality: 'final',\n          account_id: tokenContractAddress,\n          method_name: 'ft_balance_of',\n          args_base64: base64Args,\n        },\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Failed to fetch ft balance of the account');\n    }\n    const errorCause = response.body.error?.cause?.name;\n    if (errorCause !== undefined) {\n      throw new Error(errorCause);\n    }\n    const resultUint8Array: Uint8Array = new Uint8Array(response.body.result.result);\n    const raw = new TextDecoder().decode(resultUint8Array);\n    return JSON.parse(raw);\n  }\n\n  /**\n   * Function to check if storage deposit is enabled on an address for a token\n   * @param {String} accountId account for which the storage balance to be fetched\n   * @param tokenContractAddress the token contract address\n   * @returns {Promise<Boolean>} true if we find the storage balance, false if response is null\n   */\n  protected async checkIfStorageDepositIsEnabled(accountId: string, tokenContractAddress: string): Promise<boolean> {\n    const base64Args = nearUtils.convertToBase64({ account_id: accountId });\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'query',\n        params: {\n          request_type: 'call_function',\n          finality: 'final',\n          account_id: tokenContractAddress,\n          method_name: 'storage_balance_of',\n          args_base64: base64Args,\n        },\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Failed to fetch storage deposit of the account');\n    }\n    const errorCause = response.body.error?.cause?.name;\n    if (errorCause !== undefined) {\n      throw new Error(errorCause);\n    }\n    const resultUint8Array: Uint8Array = new Uint8Array(response.body.result.result);\n    const raw = new TextDecoder().decode(resultUint8Array);\n    const decoded = JSON.parse(raw);\n    return decoded !== null;\n  }\n\n  protected async getProtocolConfig(): Promise<ProtocolConfigOutput> {\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'EXPERIMENTAL_protocol_config',\n        params: {\n          finality: 'final',\n        },\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n\n    const config = response.body.result;\n    const storageAmountPerByte = config.runtime_config.storage_amount_per_byte;\n    const transferCostFromNetwork = config.runtime_config.transaction_costs.action_creation_config.transfer_cost;\n    const transferCost: NearFeeConfig = {\n      sendSir: transferCostFromNetwork.send_sir,\n      sendNotSir: transferCostFromNetwork.send_not_sir,\n      execution: transferCostFromNetwork.execution,\n    };\n\n    const receiptConfigFromNetwork = config.runtime_config.transaction_costs.action_receipt_creation_config;\n    const receiptConfig: NearFeeConfig = {\n      sendSir: receiptConfigFromNetwork.send_sir,\n      sendNotSir: receiptConfigFromNetwork.send_not_sir,\n      execution: receiptConfigFromNetwork.execution,\n    };\n    return { storageAmountPerByte, transferCost, receiptConfig };\n  }\n\n  protected async getGasPrice(blockHash: string): Promise<string> {\n    const response = await this.getDataFromNode({\n      payload: {\n        jsonrpc: '2.0',\n        id: 'dontcare',\n        method: 'gas_price',\n        params: [blockHash],\n      },\n    });\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    return response.body.result.gas_price;\n  }\n\n  protected getPublicNodeUrls(): string[] {\n    return Environments[this.bitgo.getEnv()].nearNodeUrls;\n  }\n\n  async parseTransaction(params: NearParseTransactionOptions): Promise<NearParsedTransaction> {\n    const transactionExplanation = await this.explainTransaction({\n      txPrebuild: params.txPrebuild,\n      publicKey: params.publicKey,\n      feeInfo: params.feeInfo,\n    });\n\n    if (!transactionExplanation) {\n      throw new Error('Invalid transaction');\n    }\n\n    const nearTransaction = transactionExplanation as NearTransactionExplanation;\n    if (nearTransaction.outputs.length <= 0) {\n      return {\n        inputs: [],\n        outputs: [],\n      };\n    }\n\n    const senderAddress = nearTransaction.outputs[0].address;\n    const feeAmount = new BigNumber(nearTransaction.fee.fee === '' ? '0' : nearTransaction.fee.fee);\n\n    // assume 1 sender, who is also the fee payer\n    const inputs = [\n      {\n        address: senderAddress,\n        amount: new BigNumber(nearTransaction.outputAmount).plus(feeAmount).toFixed(),\n      },\n    ];\n\n    const outputs: TransactionOutput[] = nearTransaction.outputs.map((output) => {\n      return {\n        address: output.address,\n        amount: new BigNumber(output.amount).toFixed(),\n      };\n    });\n\n    return {\n      inputs,\n      outputs,\n    };\n  }\n\n  async isWalletAddress(params: VerifyAddressOptions): Promise<boolean> {\n    throw new MethodNotImplementedError();\n  }\n\n  async verifyTransaction(params: VerifyTransactionOptions): Promise<boolean> {\n    let totalAmount = new BigNumber(0);\n    const coinConfig = coins.get(this.getChain());\n    const { txPrebuild: txPrebuild, txParams: txParams } = params;\n    const transaction = new Transaction(coinConfig);\n    const rawTx = txPrebuild.txHex;\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txHex');\n    }\n\n    transaction.fromRawTransaction(rawTx);\n    const explainedTx = transaction.explainTransaction();\n\n    // users do not input recipients for consolidation requests as they are generated by the server\n    if (txParams.recipients !== undefined) {\n      if (txParams.type === 'enabletoken') {\n        const tokenName = explainedTx.outputs[0].tokenName;\n        if (tokenName) {\n          const nepToken = nearUtils.getTokenInstanceFromTokenName(tokenName);\n          if (nepToken) {\n            explainedTx.outputs.forEach((output) => {\n              if (output.amount !== nepToken.storageDepositAmount) {\n                throw new Error('Storage deposit amount not matching!');\n              }\n            });\n          }\n        }\n      }\n\n      const filteredRecipients = txParams.recipients?.map((recipient) => {\n        if (txParams.type !== 'enabletoken') {\n          return _.pick(recipient, ['address', 'amount']);\n        } else {\n          return _.pick(recipient, ['address', 'tokenName']);\n        }\n      });\n      const filteredOutputs = explainedTx.outputs.map((output) => {\n        if (txParams.type !== 'enabletoken') {\n          return _.pick(output, ['address', 'amount']);\n        } else {\n          return _.pick(output, ['address', 'tokenName']);\n        }\n      });\n\n      if (!_.isEqual(filteredOutputs, filteredRecipients)) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n      for (const recipients of txParams.recipients) {\n        totalAmount = txParams.type !== 'enabletoken' ? totalAmount.plus(recipients.amount) : BigNumber(0);\n      }\n      if (!totalAmount.isEqualTo(explainedTx.outputAmount) && txParams.type !== 'enabletoken') {\n        throw new Error('Tx total amount does not match with expected total amount field');\n      }\n    }\n\n    if (params.verification?.consolidationToBaseAddress) {\n      await this.verifyConsolidationToBaseAddress(params, explainedTx);\n    }\n\n    return true;\n  }\n\n  private getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getBaseChain()));\n  }\n\n  /** @inheritDoc */\n  auditDecryptedKey({ prv, publicKey, multiSigType }: AuditDecryptedKeyParams) {\n    if (multiSigType !== 'tss') {\n      throw new Error('Unsupported multiSigType');\n    }\n    auditEddsaPrivateKey(prv, publicKey ?? '');\n  }\n\n  protected async verifyConsolidationToBaseAddress(\n    params: VerifyTransactionOptions,\n    explainedTx: TransactionExplanation\n  ): Promise<void> {\n    const baseAddresses: BaseAddress[] | undefined = await params.wallet.addresses({ sort: -1, limit: 1 });\n    if (!baseAddresses || baseAddresses.length === 0) {\n      throw new Error('No base address found on wallet');\n    }\n    const baseAddress = baseAddresses[0];\n\n    for (const output of explainedTx.outputs) {\n      if (output.address !== baseAddress.address) {\n        throw new Error('tx outputs does not match with expected address');\n      }\n    }\n  }\n}\n"]}