@bitgo-beta/sdk-coin-sol 7.6.4-beta.49 → 7.6.4-beta.490

package/dist/esm/sol.js

@@ -0,0 +1,1478 @@
+/**
+ * @prettier
+ */
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import BigNumber from 'bignumber.js';
+import * as base58 from 'bs58';
+import * as _ from 'lodash';
+import * as request from 'superagent';
+import { logger } from '@bitgo-beta/logger';
+import { BaseCoin, EDDSAMethods, Environments, multisigTypes, TransactionType, verifyEddsaTssWalletAddress, deriveMPCWalletAddress, UnexpectedAddressError, EDDSAUtils, } from '@bitgo-beta/sdk-core';
+import { auditEddsaPrivateKey, deriveUnhardenedMps, getDerivationPath } from '@bitgo-beta/sdk-lib-mpc';
+import { coins } from '@bitgo-beta/statics';
+import { KeyPair as SolKeyPair, Transaction, TransactionBuilder, TransactionBuilderFactory, explainSolTransaction, } from './lib';
+import { InstructionBuilderTypes } from './lib/constants';
+import { getAssociatedTokenAccountAddress, getSolTokenFromAddress, getSolTokenFromTokenName, isValidAddress, isValidPrivateKey, isValidPublicKey, validateRawTransaction, } from './lib/utils';
+export const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds
+const HEX_REGEX = /^[0-9a-fA-F]+$/;
+const BLIND_SIGNING_TX_TYPES_TO_CHECK = { enabletoken: 'AssociatedTokenAccountInitialization' };
+/**
+ * Get amount string corrected for architecture-specific endianness issues.
+ *
+ * On s390x (big-endian) architecture, the Solana transaction parser (via @solana/web3.js)
+ * incorrectly reads little-endian u64 amounts as big-endian, resulting in corrupted values.
+ *
+ * This function corrects all amounts on s390x by swapping byte order to undo
+ * the incorrect byte order that happened during transaction parsing.
+ *
+ * @param amount - The amount to check and potentially fix
+ * @returns The corrected amount as a string
+ */
+export function getAmountBasedOnEndianness(amount) {
+    const amountStr = String(amount);
+    // Only s390x architecture has this endianness issue
+    const isS390x = process.arch === 's390x';
+    if (!isS390x) {
+        return amountStr;
+    }
+    try {
+        const amountBN = BigInt(amountStr);
+        // On s390x, the parser ALWAYS reads u64 as big-endian when it's actually little-endian
+        // So we ALWAYS need to swap bytes to get the correct value
+        const buf = Buffer.alloc(8);
+        buf.writeBigUInt64BE(amountBN, 0);
+        const fixed = buf.readBigUInt64LE(0);
+        return fixed.toString();
+    }
+    catch (e) {
+        // If conversion fails, return original value
+        return amountStr;
+    }
+}
+export class Sol extends BaseCoin {
+    constructor(bitgo, staticsCoin) {
+        super(bitgo);
+        if (!staticsCoin) {
+            throw new Error('missing required constructor parameter staticsCoin');
+        }
+        this._staticsCoin = staticsCoin;
+    }
+    static createInstance(bitgo, staticsCoin) {
+        return new Sol(bitgo, staticsCoin);
+    }
+    allowsAccountConsolidations() {
+        return true;
+    }
+    supportsTss() {
+        return true;
+    }
+    /** @inheritDoc */
+    supportsMessageSigning() {
+        return true;
+    }
+    /** inherited doc */
+    getDefaultMultisigType() {
+        return multisigTypes.tss;
+    }
+    getMPCAlgorithm() {
+        return 'eddsa';
+    }
+    getChain() {
+        return this._staticsCoin.name;
+    }
+    getFamily() {
+        return this._staticsCoin.family;
+    }
+    getFullName() {
+        return this._staticsCoin.fullName;
+    }
+    getNetwork() {
+        return this._staticsCoin.network;
+    }
+    getBaseFactor() {
+        return Math.pow(10, this._staticsCoin.decimalPlaces);
+    }
+    verifyTxType(expectedTypeFromUserParams, actualTypeFromDecoded) {
+        const matchFromUserToDecodedType = BLIND_SIGNING_TX_TYPES_TO_CHECK[expectedTypeFromUserParams];
+        if (matchFromUserToDecodedType !== actualTypeFromDecoded) {
+            throw new Error(`Invalid transaction type on token enablement: expected "${matchFromUserToDecodedType}", got "${actualTypeFromDecoded}".`);
+        }
+    }
+    throwIfMissingTokenEnablementsOrReturn(explanation) {
+        if (!explanation.tokenEnablements || explanation.tokenEnablements.length === 0)
+            throw new Error('Missing tx token enablements data on token enablement tx prebuild');
+        return explanation.tokenEnablements;
+    }
+    throwIfMissingEnableTokenConfigOrReturn(txParams) {
+        if (!txParams.enableTokens || txParams.enableTokens.length === 0)
+            throw new Error('Missing enable token config');
+        return txParams.enableTokens;
+    }
+    verifyTokenName(tokenEnablementsPrebuild, enableTokensConfig) {
+        enableTokensConfig.forEach((enableTokenConfig) => {
+            const expectedTokenName = enableTokenConfig.name;
+            tokenEnablementsPrebuild.forEach((tokenEnablement) => {
+                if (!tokenEnablement.tokenName)
+                    throw new Error('Missing token name on token enablement tx');
+                if (tokenEnablement.tokenName !== expectedTokenName)
+                    throw new Error(`Invalid token name: expected ${expectedTokenName}, got ${tokenEnablement.tokenName} on token enablement tx`);
+            });
+        });
+    }
+    async verifyTokenAddress(tokenEnablementsPrebuild, enableTokensConfig) {
+        for (const enableTokenConfig of enableTokensConfig) {
+            const expectedTokenAddress = enableTokenConfig.address;
+            const expectedTokenName = enableTokenConfig.name;
+            if (!expectedTokenAddress)
+                throw new Error('Missing token address on token enablement tx');
+            if (!expectedTokenName)
+                throw new Error('Missing token name on token enablement tx');
+            for (const tokenEnablement of tokenEnablementsPrebuild) {
+                let tokenMintAddress;
+                try {
+                    tokenMintAddress = getSolTokenFromTokenName(expectedTokenName);
+                }
+                catch {
+                    throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`);
+                }
+                if (!tokenMintAddress ||
+                    tokenMintAddress.tokenAddress === undefined ||
+                    tokenMintAddress.programId === undefined) {
+                    throw new Error(`Unable to get token mint address for ${expectedTokenName}`);
+                }
+                let ata;
+                try {
+                    ata = await getAssociatedTokenAccountAddress(tokenMintAddress.tokenAddress, expectedTokenAddress, true, tokenMintAddress.programId);
+                }
+                catch {
+                    throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`);
+                }
+                if (ata !== tokenEnablement.address) {
+                    throw new Error(`Invalid token address: expected ${ata}, got ${tokenEnablement.address} on token enablement tx`);
+                }
+            }
+        }
+    }
+    /**
+     * For transactions typed as `CloseAssociatedTokenAccount` (includes SPL close-account and
+     * recover-nested flows), enforce that rent / authority aligns with the wallet root when known.
+     *
+     * No-op when `walletRootAddress` is not provided (e.g. uninitialized wallets).
+     */
+    verifyCloseAssociatedTokenAccountFamilyRoots(transaction, walletRootAddress) {
+        if (!walletRootAddress) {
+            return;
+        }
+        const txJson = transaction.toJson();
+        for (const instruction of txJson.instructionsData) {
+            if (instruction.type === InstructionBuilderTypes.CloseAssociatedTokenAccount) {
+                const closeInstruction = instruction;
+                if (closeInstruction.params.destinationAddress !== walletRootAddress) {
+                    throw new Error(`Close ATA destination must be wallet root address. Expected ${walletRootAddress}, got ${closeInstruction.params.destinationAddress}`);
+                }
+            }
+            else if (instruction.type === InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount) {
+                const recoverNestedInstruction = instruction;
+                if (recoverNestedInstruction.params.walletAddress !== walletRootAddress) {
+                    throw new Error(`Recover nested wallet address must be wallet root address. Expected ${walletRootAddress}, got ${recoverNestedInstruction.params.walletAddress}`);
+                }
+            }
+        }
+    }
+    /**
+     * When the caller supplies `recipients` for a close-ATA prebuild, require they match the
+     * on-chain ATA accounts being closed (order-independent) and carry zero amount (intent-only).
+     * Recover-nested-only txs have no close instructions; this is a no-op in that case.
+     */
+    verifyCloseAtaRecipientsMatchCloseInstructions(transaction, recipients) {
+        const txJson = transaction.toJson();
+        const closeAtaAccountAddresses = txJson.instructionsData
+            .filter((inst) => inst.type === InstructionBuilderTypes.CloseAssociatedTokenAccount)
+            .map((inst) => inst.params.accountAddress);
+        if (closeAtaAccountAddresses.length === 0) {
+            return;
+        }
+        for (const recipient of recipients) {
+            if (recipient.tokenName) {
+                throw new Error('Close ATA recipients must not specify tokenName');
+            }
+            if (!new BigNumber(String(recipient.amount ?? '0')).isZero()) {
+                throw new Error('Close ATA recipients must have zero amount');
+            }
+        }
+        const sortedRecipients = [...recipients.map((r) => r.address)].sort();
+        const sortedCloses = [...closeAtaAccountAddresses].sort();
+        if (!_.isEqual(sortedRecipients, sortedCloses)) {
+            throw new Error('Close ATA txParams.recipients addresses must match the ATA account addresses in the transaction instructions');
+        }
+    }
+    hasSolVersionedTransactionData(txParams) {
+        return 'solVersionedTransactionData' in txParams && txParams.solVersionedTransactionData !== undefined;
+    }
+    /**
+     * Verify a versioned Solana transaction with basic structural validation
+     * @param params - verification parameters
+     * @returns true if verification passes
+     */
+    async verifyVersionedTransaction(params) {
+        const { txParams, txPrebuild } = params;
+        const rawTx = txPrebuild.txBase64 || txPrebuild.txHex;
+        if (!rawTx) {
+            throw new Error('missing required tx prebuild property txBase64 or txHex');
+        }
+        // Validate that the versioned transaction data is well-formed
+        if (!this.hasSolVersionedTransactionData(txParams)) {
+            throw new Error('solVersionedTransactionData is required for versioned transaction verification');
+        }
+        const versionedData = txParams.solVersionedTransactionData;
+        if (!versionedData.versionedInstructions || versionedData.versionedInstructions.length === 0) {
+            throw new Error('versioned transaction must have at least one instruction');
+        }
+        if (!versionedData.staticAccountKeys || versionedData.staticAccountKeys.length === 0) {
+            throw new Error('versioned transaction must have at least one static account key');
+        }
+        if (!versionedData.messageHeader) {
+            throw new Error('versioned transaction must have a message header');
+        }
+        // Validate that we can deserialize the transaction
+        let rawTxBase64 = rawTx;
+        if (HEX_REGEX.test(rawTx)) {
+            rawTxBase64 = Buffer.from(rawTx, 'hex').toString('base64');
+        }
+        try {
+            const txBytes = Buffer.from(rawTxBase64, 'base64');
+            if (txBytes.length < 1) {
+                throw new Error('transaction bytes are empty');
+            }
+            // Check version byte (after signatures)
+            const numSignatures = txBytes[0];
+            const signatureSize = 64;
+            const versionByteOffset = 1 + numSignatures * signatureSize;
+            if (txBytes.length <= versionByteOffset) {
+                throw new Error('transaction bytes are too short to contain version byte');
+            }
+            const versionByte = txBytes[versionByteOffset];
+            const isVersioned = (versionByte & 0x80) !== 0;
+            if (!isVersioned) {
+                throw new Error('transaction does not have versioned format');
+            }
+        }
+        catch (error) {
+            throw new Error(`failed to validate versioned transaction format: ${error.message}`);
+        }
+        return true;
+    }
+    async verifyTransaction(params) {
+        // asset name to transfer amount map
+        const totalAmount = {};
+        const coinConfig = coins.get(this.getChain());
+        const { txParams: txParams, txPrebuild: txPrebuild, memo: memo, durableNonce: durableNonce, verification: verificationOptions, } = params;
+        if (this.hasSolVersionedTransactionData(txParams)) {
+            return this.verifyVersionedTransaction(params);
+        }
+        const transaction = new Transaction(coinConfig);
+        const rawTx = txPrebuild.txBase64 || txPrebuild.txHex;
+        const consolidateId = txPrebuild.consolidateId;
+        const walletRootAddress = params.wallet.coinSpecific()?.rootAddress;
+        if (!rawTx) {
+            throw new Error('missing required tx prebuild property txBase64 or txHex');
+        }
+        let rawTxBase64 = rawTx;
+        if (HEX_REGEX.test(rawTx)) {
+            rawTxBase64 = Buffer.from(rawTx, 'hex').toString('base64');
+        }
+        transaction.fromRawTransaction(rawTxBase64);
+        const explainedTx = transaction.explainTransaction();
+        const isCloseAssociatedTokenAccountTx = transaction.type === TransactionType.CloseAssociatedTokenAccount;
+        if (txParams.type === 'enabletoken' && verificationOptions?.verifyTokenEnablement) {
+            this.verifyTxType(txParams.type, explainedTx.type);
+            const tokenEnablementsPrebuild = this.throwIfMissingTokenEnablementsOrReturn(explainedTx);
+            const enableTokensConfig = this.throwIfMissingEnableTokenConfigOrReturn(txParams);
+            this.verifyTokenName(tokenEnablementsPrebuild, enableTokensConfig);
+            await this.verifyTokenAddress(tokenEnablementsPrebuild, enableTokensConfig);
+        }
+        if (isCloseAssociatedTokenAccountTx) {
+            this.verifyCloseAssociatedTokenAccountFamilyRoots(transaction, walletRootAddress);
+            if (txParams.recipients !== undefined) {
+                this.verifyCloseAtaRecipientsMatchCloseInstructions(transaction, txParams.recipients);
+            }
+        }
+        const isTokenEnablementTx = txParams.type === 'enabletoken';
+        // users do not input recipients for consolidation requests as they are generated by the server
+        // Close-ATA txs do not populate explainedTx.outputs; recipients carry ATA addresses for intent only.
+        if (txParams.recipients !== undefined && !isTokenEnablementTx && !isCloseAssociatedTokenAccountTx) {
+            const filteredRecipients = txParams.recipients?.map((recipient) => _.pick(recipient, ['address', 'amount', 'tokenName']));
+            const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));
+            if (filteredRecipients.length !== filteredOutputs.length) {
+                throw new Error('Number of tx outputs does not match with number of txParams recipients');
+            }
+            // For each recipient, check if it's a token tx (tokenName will exist if so)
+            // If it is a token tx, verify that the recipient address equals the derived address from explainedTx
+            // Derive the ATA if it is a native address and confirm it is equal to the explained tx recipient
+            const recipientChecks = await Promise.all(filteredRecipients.map(async (recipientFromUser, index) => {
+                const recipientFromTx = filteredOutputs[index]; // This address should be an ATA
+                // Compare the BigNumber values because amount is (string | number)
+                // Apply s390x endianness fix if needed
+                const userAmountStr = String(recipientFromUser.amount);
+                const txAmountStr = getAmountBasedOnEndianness(recipientFromTx.amount);
+                const userAmount = new BigNumber(userAmountStr);
+                const txAmount = new BigNumber(txAmountStr);
+                if (!userAmount.isEqualTo(txAmount)) {
+                    return false;
+                }
+                // Compare the addresses and tokenNames
+                // Else if the addresses are not the same, check the derived ATA for parity
+                if (recipientFromUser.address === recipientFromTx.address &&
+                    recipientFromUser.tokenName === recipientFromTx.tokenName) {
+                    return true;
+                }
+                else if (recipientFromUser.address !== recipientFromTx.address && recipientFromUser.tokenName) {
+                    // Try to check if the user's derived ATA is equal to the tx recipient address
+                    // If getAssociatedTokenAccountAddress throws an error, then we are unable to derive the ATA for that address.
+                    // Return false and throw an error if that is the case.
+                    try {
+                        const tokenMintAddress = getSolTokenFromTokenName(recipientFromUser.tokenName);
+                        return getAssociatedTokenAccountAddress(tokenMintAddress.tokenAddress, recipientFromUser.address, true, tokenMintAddress.programId).then((ata) => {
+                            return ata === recipientFromTx.address;
+                        });
+                    }
+                    catch {
+                        // Unable to derive ATA
+                        return false;
+                    }
+                }
+                return false;
+            }));
+            if (recipientChecks.includes(false)) {
+                throw new Error('Tx outputs does not match with expected txParams recipients');
+            }
+        }
+        else if (verificationOptions?.consolidationToBaseAddress) {
+            //verify funds are sent to walletRootAddress for a consolidation
+            const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));
+            // Cache to store already derived ATA addresses
+            const ataAddressCache = {};
+            for (const output of filteredOutputs) {
+                if (output.tokenName) {
+                    // Check cache first before deriving ATA address
+                    if (!ataAddressCache[output.tokenName]) {
+                        const tokenMintAddress = getSolTokenFromTokenName(output.tokenName);
+                        if (tokenMintAddress?.tokenAddress && tokenMintAddress?.programId) {
+                            ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(tokenMintAddress.tokenAddress, walletRootAddress, true, tokenMintAddress.programId);
+                        }
+                        else {
+                            throw new Error(`Unable to get token information for ${output.tokenName}`);
+                        }
+                    }
+                    if (ataAddressCache[output.tokenName] !== output.address) {
+                        throw new Error('tx outputs does not match with expected address');
+                    }
+                }
+                else if (output.address !== walletRootAddress) {
+                    throw new Error('tx outputs does not match with expected address');
+                }
+            }
+        }
+        const transactionJson = transaction.toJson();
+        if (memo && memo.value !== explainedTx.memo) {
+            throw new Error('Tx memo does not match with expected txParams recipient memo');
+        }
+        if (txParams.recipients && !isTokenEnablementTx && !isCloseAssociatedTokenAccountTx) {
+            for (const recipients of txParams.recipients) {
+                // totalAmount based on each token
+                const assetName = recipients.tokenName || this.getChain();
+                const amount = totalAmount[assetName] || new BigNumber(0);
+                totalAmount[assetName] = amount.plus(recipients.amount);
+            }
+            // total output amount from explainedTx
+            const explainedTxTotal = {};
+            for (const output of explainedTx.outputs) {
+                // Apply s390x endianness fix to output amounts before summing
+                const outputAmountStr = getAmountBasedOnEndianness(output.amount);
+                // total output amount based on each token
+                const assetName = output.tokenName || this.getChain();
+                const amount = explainedTxTotal[assetName] || new BigNumber(0);
+                explainedTxTotal[assetName] = amount.plus(outputAmountStr);
+            }
+            if (!_.isEqual(explainedTxTotal, totalAmount)) {
+                throw new Error('Tx total amount does not match with expected total amount field');
+            }
+        }
+        // For non-consolidate transactions, feePayer must be the wallet's root address
+        if (consolidateId === undefined && transactionJson.feePayer !== walletRootAddress) {
+            throw new Error('Tx fee payer is not the wallet root address');
+        }
+        if (durableNonce && !_.isEqual(explainedTx.durableNonce, durableNonce)) {
+            throw new Error('Tx durableNonce does not match with param durableNonce');
+        }
+        return true;
+    }
+    async isWalletAddress(params) {
+        const result = await verifyEddsaTssWalletAddress(params, (address) => this.isValidAddress(address), (publicKey) => this.getAddressFromPublicKey(publicKey));
+        if (!result) {
+            throw new UnexpectedAddressError(`address validation failure: ${params.address} is not a wallet address`);
+        }
+        return true;
+    }
+    /**
+     * Locally derive a SOL wallet receive address from a derivation path, using the wallet's
+     * commonKeychain only (no private keys, no network access). This is the inverse of
+     * {@link isWalletAddress}: it *produces* the address via the same EdDSA TSS derivation that
+     * isWalletAddress checks against, so the two can never diverge.
+     * @param params keychains (commonKeychain), derivation index, and optional SMC seed
+     * @returns the derived address, the index used, and the HD derivation path
+     */
+    async deriveAddress(params) {
+        const { address, derivationPath } = await deriveMPCWalletAddress({
+            // extractCommonKeychain validates the commonKeychain is present at runtime
+            keychains: (params.keychains ?? []),
+            index: params.index,
+            derivedFromParentWithSeed: params.derivedFromParentWithSeed,
+            multisigTypeVersion: params.multisigTypeVersion,
+            keyCurve: 'ed25519',
+        }, (publicKey) => this.getAddressFromPublicKey(publicKey));
+        return { address, index: params.index, derivationPath };
+    }
+    /**
+     * Converts a Solana public key to an address
+     * @param publicKey Hex-encoded public key (64 hex characters = 32 bytes)
+     * @returns Base58-encoded Solana address
+     */
+    getAddressFromPublicKey(publicKey) {
+        const publicKeyBuffer = Buffer.from(publicKey, 'hex');
+        return base58.encode(publicKeyBuffer);
+    }
+    /**
+     * Generate Solana key pair
+     *
+     * @param {Buffer} seed - Seed from which the new SolKeyPair should be generated, otherwise a random seed is used
+     * @returns {Object} object with generated pub and prv
+     */
+    generateKeyPair(seed) {
+        const result = seed ? new SolKeyPair({ seed }).getKeys() : new SolKeyPair().getKeys();
+        return result;
+    }
+    /**
+     * Return boolean indicating whether input is valid public key for the coin
+     *
+     * @param {string} pub the prv to be checked
+     * @returns is it valid?
+     */
+    isValidPub(pub) {
+        return isValidPublicKey(pub);
+    }
+    /**
+     * Return boolean indicating whether input is valid private key for the coin
+     *
+     * @param {string} prv the prv to be checked
+     * @returns is it valid?
+     */
+    isValidPrv(prv) {
+        return isValidPrivateKey(prv);
+    }
+    isValidAddress(address) {
+        return isValidAddress(address);
+    }
+    async signMessage(key, message) {
+        const solKeypair = new SolKeyPair({ prv: key.prv });
+        if (Buffer.isBuffer(message)) {
+            message = base58.encode(message);
+        }
+        return Buffer.from(solKeypair.signMessage(message));
+    }
+    /**
+     * Signs Solana transaction
+     * @param params
+     * @param callback
+     */
+    async signTransaction(params) {
+        const factory = this.getBuilder();
+        const rawTx = params.txPrebuild.txHex || params.txPrebuild.txBase64;
+        const txBuilder = factory.from(rawTx);
+        txBuilder.sign({ key: params.prv });
+        const transaction = await txBuilder.build();
+        if (!transaction) {
+            throw new Error('Invalid transaction');
+        }
+        const serializedTx = transaction.toBroadcastFormat();
+        return {
+            txHex: serializedTx,
+        };
+    }
+    async parseTransaction(params) {
+        // explainTransaction now uses WASM for testnet automatically
+        const transactionExplanation = await this.explainTransaction({
+            txBase64: params.txBase64,
+            feeInfo: params.feeInfo,
+            tokenAccountRentExemptAmount: params.tokenAccountRentExemptAmount,
+        });
+        if (!transactionExplanation) {
+            throw new Error('Invalid transaction');
+        }
+        const solTransaction = transactionExplanation;
+        if (solTransaction.outputs.length <= 0) {
+            return {
+                inputs: [],
+                outputs: [],
+            };
+        }
+        const senderAddress = solTransaction.outputs[0].address;
+        const feeAmount = new BigNumber(solTransaction.fee.fee);
+        // assume 1 sender, who is also the fee payer
+        const inputs = [
+            {
+                address: senderAddress,
+                amount: new BigNumber(solTransaction.outputAmount).plus(feeAmount).toNumber(),
+            },
+        ];
+        const outputs = solTransaction.outputs.map(({ address, amount, tokenName }) => {
+            const output = { address, amount };
+            if (tokenName) {
+                output.tokenName = tokenName;
+            }
+            return output;
+        });
+        return {
+            inputs,
+            outputs,
+        };
+    }
+    /**
+     * Explain a Solana transaction from txBase64
+     * Uses WASM-based parsing for testnet, with fallback to legacy builder approach.
+     * @param params
+     */
+    async explainTransaction(params) {
+        // Use WASM-based parsing for testnet (simpler, faster, no @solana/web3.js rebuild)
+        if (this.getChain() === 'tsol') {
+            return this.explainTransactionWithWasm(params);
+        }
+        // Legacy approach for mainnet (until WASM is fully validated)
+        const factory = this.getBuilder();
+        let rebuiltTransaction;
+        try {
+            const transactionBuilder = factory.from(params.txBase64);
+            if (transactionBuilder instanceof TransactionBuilder) {
+                const txBuilder = transactionBuilder;
+                txBuilder.fee({ amount: params.feeInfo.fee });
+                if (params.tokenAccountRentExemptAmount) {
+                    txBuilder.associatedTokenAccountRent(params.tokenAccountRentExemptAmount);
+                }
+            }
+            rebuiltTransaction = await transactionBuilder.build();
+        }
+        catch (e) {
+            logger.error(e);
+            throw new Error('Invalid transaction');
+        }
+        const explainedTransaction = rebuiltTransaction.explainTransaction();
+        return explainedTransaction;
+    }
+    /**
+     * Explain a Solana transaction using WASM parsing (bypasses @solana/web3.js rebuild).
+     * Delegates to standalone explainSolTransaction().
+     */
+    explainTransactionWithWasm(params) {
+        return explainSolTransaction({ ...params, coinName: params.coinName ?? this.getChain() });
+    }
+    /** @inheritDoc */
+    async getSignablePayload(serializedTx) {
+        const factory = this.getBuilder();
+        const rebuiltTransaction = await factory.from(serializedTx).build();
+        return rebuiltTransaction.signablePayload;
+    }
+    /** @inheritDoc */
+    async presignTransaction(params) {
+        // Hot wallet txns are only valid for 1-2 minutes.
+        // To buy more time, we rebuild the transaction with a new blockhash right before we sign.
+        if (params.walletData.type !== 'hot') {
+            return Promise.resolve(params);
+        }
+        const txRequestId = params.txPrebuild?.txRequestId;
+        if (txRequestId === undefined) {
+            throw new Error('Missing txRequestId');
+        }
+        const { tssUtils } = params;
+        await tssUtils.deleteSignatureShares(txRequestId);
+        const recreated = await tssUtils.getTxRequest(txRequestId);
+        let txHex = '';
+        if (recreated.unsignedTxs) {
+            txHex = recreated.unsignedTxs[0]?.serializedTxHex;
+        }
+        else {
+            txHex = recreated.transactions ? recreated.transactions[0]?.unsignedTx.serializedTxHex : '';
+        }
+        if (!txHex) {
+            throw new Error('Missing serialized tx hex');
+        }
+        return Promise.resolve({
+            ...params,
+            txPrebuild: recreated,
+            txHex,
+        });
+    }
+    getPublicNodeUrl(apiKey) {
+        if (apiKey) {
+            return Environments[this.bitgo.getEnv()].solAlchemyNodeUrl + `/${apiKey}`;
+        }
+        return Environments[this.bitgo.getEnv()].solNodeUrl;
+    }
+    /**
+     * Make a request to one of the public SOL nodes available
+     * @param params.payload
+     */
+    async getDataFromNode(params, apiKey) {
+        const nodeUrl = this.getPublicNodeUrl(apiKey);
+        try {
+            return await request.post(nodeUrl).send(params.payload);
+        }
+        catch (e) {
+            console.debug(e);
+        }
+        throw new Error(`Unable to call endpoint: '/' from node: ${nodeUrl}`);
+    }
+    async getBlockhash(apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getLatestBlockhash',
+                params: [
+                    {
+                        commitment: 'finalized',
+                    },
+                ],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return response.body.result.value.blockhash;
+    }
+    async getFeeForMessage(message, apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getFeeForMessage',
+                params: [
+                    message,
+                    {
+                        commitment: 'finalized',
+                    },
+                ],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return response.body.result.value;
+    }
+    async getRentExemptAmount(apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                jsonrpc: '2.0',
+                id: '1',
+                method: 'getMinimumBalanceForRentExemption',
+                params: [165],
+            },
+        }, apiKey);
+        if (response.status !== 200 || response.error) {
+            throw new Error(JSON.stringify(response.error));
+        }
+        return response.body.result;
+    }
+    async getAccountBalance(pubKey, apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getBalance',
+                params: [pubKey],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return response.body.result.value;
+    }
+    async getAccountInfo(pubKey, apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getAccountInfo',
+                params: [
+                    pubKey,
+                    {
+                        encoding: 'jsonParsed',
+                    },
+                ],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return {
+            authority: response.body.result.value.data.parsed.info.authority,
+            blockhash: response.body.result.value.data.parsed.info.blockhash,
+        };
+    }
+    async getTokenAccountsByOwner(pubKey = '', programId = '', apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getTokenAccountsByOwner',
+                params: [
+                    pubKey,
+                    {
+                        programId: programId.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()
+                            ? TOKEN_2022_PROGRAM_ID.toString()
+                            : TOKEN_PROGRAM_ID.toString(),
+                    },
+                    {
+                        encoding: 'jsonParsed',
+                    },
+                ],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        if (response.body.result.value.length !== 0) {
+            const tokenAccounts = [];
+            for (const tokenAccount of response.body.result.value) {
+                tokenAccounts.push({ info: tokenAccount.account.data.parsed.info, pubKey: tokenAccount.pubKey });
+            }
+            return tokenAccounts;
+        }
+        return [];
+    }
+    async getTokenAccountInfo(pubKey, apiKey) {
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'getAccountInfo',
+                params: [
+                    pubKey,
+                    {
+                        encoding: 'jsonParsed',
+                    },
+                ],
+            },
+        }, apiKey);
+        if (response.status !== 200) {
+            throw new Error('Account not found');
+        }
+        return {
+            pubKey: pubKey,
+            info: response.body.result.value.data.parsed.info,
+        };
+    }
+    /** inherited doc */
+    async createBroadcastableSweepTransaction(params) {
+        if (!params.signatureShares) {
+            ('Missing transaction(s)');
+        }
+        const req = params.signatureShares;
+        const broadcastableTransactions = [];
+        let lastScanIndex = 0;
+        for (let i = 0; i < req.length; i++) {
+            const MPC = await EDDSAMethods.getInitializedMpcInstance();
+            const transaction = req[i].txRequest.transactions[0].unsignedTx;
+            if (!req[i].ovc || !req[i].ovc[0].eddsaSignature) {
+                throw new Error('Missing signature(s)');
+            }
+            const signature = req[i].ovc[0].eddsaSignature;
+            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');
+            }
+            const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);
+            const txBuilder = this.getBuilder().from(transaction.serializedTx);
+            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 bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();
+            // add combined signature from ovc
+            const publicKeyObj = { pub: bs58EncodedPublicKey };
+            txBuilder.addSignature(publicKeyObj, signatureHex);
+            const signedTransaction = await txBuilder.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 };
+    }
+    /**
+     * Builds a funds recovery transaction without BitGo
+     * @param {SolRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     *
+     * @returns {MPCTx | MPCSweepTxs} the serialized transaction hex string and index
+     * of the address being swept
+     */
+    async recover(params) {
+        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.walletPassphrase;
+        // Validate signing keys and detect MPCv2 format early for signed recovery
+        let isMpcV2 = false;
+        if (params.walletPassphrase) {
+            if (!params.userKey) {
+                throw new Error('missing userKey');
+            }
+            if (!params.backupKey) {
+                throw new Error('missing backupKey');
+            }
+            // Detect MPCv2 keycards — will throw if decryption fails (e.g., wrong password).
+            // MPCv1 keycards decrypt to JSON with uShare/bitgoYShare; MPCv2 keycards are CBOR.
+            try {
+                const isV1 = await EDDSAUtils.EddsaMPCv2RecoveryFunctions.isEddsaMpcV1SigningMaterial(params.userKey.replace(/\s/g, ''), params.walletPassphrase, this.bitgo);
+                isMpcV2 = !isV1;
+            }
+            catch (e) {
+                // Re-wrap decryption errors with context
+                throw new Error(`Error decrypting user keychain: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        let balance = 0;
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        let accountId;
+        if (isMpcV2) {
+            accountId = deriveUnhardenedMps(bitgoKey, currPath).slice(0, 64);
+        }
+        else {
+            const MPC = await EDDSAMethods.getInitializedMpcInstance();
+            accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+        }
+        const bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();
+        balance = await this.getAccountBalance(bs58EncodedPublicKey, params.apiKey);
+        const factory = this.getBuilder();
+        const walletCoin = this.getChain();
+        let txBuilder;
+        let blockhash = await this.getBlockhash(params.apiKey);
+        let rentExemptAmount;
+        let authority = '';
+        let totalFee = new BigNumber(0);
+        let totalFeeForTokenRecovery = new BigNumber(0);
+        // check for possible token recovery, recover the token provide by user
+        if (params.tokenContractAddress) {
+            let isUnsupportedToken = false;
+            const tokenAccounts = await this.getTokenAccountsByOwner(bs58EncodedPublicKey, params.programId, params.apiKey);
+            if (tokenAccounts.length !== 0) {
+                // there exists token accounts on the given address, but need to check certain conditions:
+                // 1. if there is a recoverable balance
+                // 2. if the token is supported by bitgo
+                const recovereableTokenAccounts = [];
+                for (const tokenAccount of tokenAccounts) {
+                    if (params.tokenContractAddress === tokenAccount.info.mint) {
+                        const tokenAmount = new BigNumber(tokenAccount.info.tokenAmount.amount);
+                        const network = this.getNetwork();
+                        const token = getSolTokenFromAddress(tokenAccount.info.mint, network); // todo(WIN-5894) fix for ams
+                        if (!token) {
+                            isUnsupportedToken = true;
+                        }
+                        if (tokenAmount.gt(new BigNumber(0))) {
+                            tokenAccount.tokenName = token?.name || 'Unsupported Token';
+                            recovereableTokenAccounts.push(tokenAccount);
+                        }
+                        break;
+                    }
+                }
+                if (recovereableTokenAccounts.length !== 0) {
+                    rentExemptAmount = await this.getRentExemptAmount(params.apiKey);
+                    txBuilder = factory
+                        .getTokenTransferBuilder()
+                        .nonce(blockhash)
+                        .sender(bs58EncodedPublicKey)
+                        .associatedTokenAccountRent(rentExemptAmount.toString())
+                        .feePayer(bs58EncodedPublicKey);
+                    // need to get all token accounts of the recipient address and need to create them if they do not exist
+                    const recipientTokenAccounts = await this.getTokenAccountsByOwner(params.recoveryDestination, params.programId, params.apiKey);
+                    for (const tokenAccount of recovereableTokenAccounts) {
+                        let recipientTokenAccountExists = false;
+                        for (const recipientTokenAccount of recipientTokenAccounts) {
+                            if (recipientTokenAccount.info.mint === tokenAccount.info.mint) {
+                                recipientTokenAccountExists = true;
+                                break;
+                            }
+                        }
+                        const recipientTokenAccount = await getAssociatedTokenAccountAddress(tokenAccount.info.mint, params.recoveryDestination, false, params.programId?.toString());
+                        const tokenName = tokenAccount.tokenName;
+                        const sendParams = {
+                            address: recipientTokenAccount,
+                            amount: tokenAccount.info.tokenAmount.amount,
+                            tokenName,
+                            ...(isUnsupportedToken
+                                ? {
+                                    tokenAddress: tokenAccount.info.mint,
+                                    programId: params.programId?.toString(),
+                                    decimalPlaces: tokenAccount.info.tokenAmount.decimals,
+                                }
+                                : {}),
+                        };
+                        txBuilder.send(sendParams);
+                        if (!recipientTokenAccountExists) {
+                            // recipient token account does not exist for token and must be created
+                            txBuilder.createAssociatedTokenAccount({
+                                ownerAddress: params.recoveryDestination,
+                                tokenName: tokenName,
+                                ...(isUnsupportedToken ? { tokenAddress: tokenAccount.info.mint } : {}),
+                                programId: params.programId?.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()
+                                    ? TOKEN_2022_PROGRAM_ID.toString()
+                                    : TOKEN_PROGRAM_ID.toString(),
+                            });
+                            // add rent exempt amount to total fee for each token account that has to be created
+                            totalFeeForTokenRecovery = totalFeeForTokenRecovery.plus(rentExemptAmount);
+                        }
+                    }
+                }
+                else {
+                    throw Error('Not enough token funds to recover');
+                }
+            }
+            else {
+                // there are no recoverable token accounts , need to check if there are tokens to recover
+                throw Error('Did not find token account to recover tokens, please check token account');
+            }
+        }
+        else {
+            txBuilder = factory
+                .getTransferBuilder()
+                .nonce(blockhash)
+                .sender(bs58EncodedPublicKey)
+                .send({ address: params.recoveryDestination, amount: balance.toString() })
+                .feePayer(bs58EncodedPublicKey);
+        }
+        if (params.durableNonce) {
+            const durableNonceInfo = await this.getAccountInfo(params.durableNonce.publicKey, params.apiKey);
+            blockhash = durableNonceInfo.blockhash;
+            authority = durableNonceInfo.authority;
+            txBuilder.nonce(blockhash, {
+                walletNonceAddress: params.durableNonce.publicKey,
+                authWalletAddress: authority,
+            });
+        }
+        // build the transaction without fee
+        const unsignedTransactionWithoutFee = (await txBuilder.build());
+        const serializedMessage = unsignedTransactionWithoutFee.solTransaction.serializeMessage().toString('base64');
+        const baseFee = await this.getFeeForMessage(serializedMessage, params.apiKey);
+        const feePerSignature = params.durableNonce ? baseFee / 2 : baseFee;
+        totalFee = totalFee.plus(new BigNumber(baseFee));
+        totalFeeForTokenRecovery = totalFeeForTokenRecovery.plus(new BigNumber(baseFee));
+        if (totalFee.gt(balance)) {
+            throw Error('Did not find address with funds to recover');
+        }
+        if (params.tokenContractAddress) {
+            // Check if there is sufficient native solana to recover tokens
+            if (new BigNumber(balance).lt(totalFeeForTokenRecovery)) {
+                throw Error('Not enough funds to pay for recover tokens fees, have: ' +
+                    balance +
+                    ' need: ' +
+                    totalFeeForTokenRecovery.toString());
+            }
+            txBuilder.fee({ amount: feePerSignature });
+        }
+        else {
+            const netAmount = new BigNumber(balance).minus(totalFee);
+            txBuilder = factory
+                .getTransferBuilder()
+                .nonce(blockhash)
+                .sender(bs58EncodedPublicKey)
+                .send({ address: params.recoveryDestination, amount: netAmount.toString() })
+                .feePayer(bs58EncodedPublicKey)
+                .fee({ amount: feePerSignature });
+            if (params.durableNonce) {
+                txBuilder.nonce(blockhash, {
+                    walletNonceAddress: params.durableNonce.publicKey,
+                    authWalletAddress: authority,
+                });
+            }
+        }
+        if (!isUnsignedSweep) {
+            // Sign the txn
+            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');
+            }
+            // build the transaction with fee
+            const unsignedTransaction = (await txBuilder.build());
+            const userKey = params.userKey.replace(/\s/g, '');
+            const backupKey = params.backupKey.replace(/\s/g, '');
+            if (!isMpcV2) {
+                // MPCv1 path: decrypt JSON signing material and use TSS signing
+                let userPrv;
+                try {
+                    userPrv = await this.bitgo.decryptAsync({
+                        input: userKey,
+                        password: params.walletPassphrase,
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Error decrypting user keychain: ${e.message}`);
+                }
+                const userSigningMaterial = JSON.parse(userPrv);
+                let backupPrv;
+                try {
+                    backupPrv = await this.bitgo.decryptAsync({
+                        input: backupKey,
+                        password: params.walletPassphrase,
+                    });
+                }
+                catch (e) {
+                    throw new Error(`Error decrypting backup keychain: ${e.message}`);
+                }
+                const backupSigningMaterial = JSON.parse(backupPrv);
+                const signatureHex = await EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, currPath, unsignedTransaction);
+                txBuilder.addSignature({ pub: bs58EncodedPublicKey }, signatureHex);
+            }
+            else {
+                // MPCv2 path: decrypt CBOR reduced key shares and sign with MPS DSG protocol
+                const { userKeyShare, backupKeyShare, commonKeyChain } = await EDDSAUtils.EddsaMPCv2RecoveryFunctions.getEddsaMpcV2RecoveryKeySharesFromReducedKey(userKey, backupKey, params.walletPassphrase, this.bitgo);
+                if (commonKeyChain.toLowerCase() !== bitgoKey.toLowerCase()) {
+                    throw new Error('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');
+                }
+                const signature = EDDSAUtils.EddsaMPCv2RecoveryFunctions.signRecoveryEddsaMPCv2(unsignedTransaction.signablePayload, currPath, userKeyShare, backupKeyShare, commonKeyChain);
+                txBuilder.addSignature({ pub: bs58EncodedPublicKey }, signature);
+            }
+        }
+        if (params.durableNonce) {
+            // add durable nonce account signature
+            txBuilder.sign({ key: params.durableNonce.secretKey });
+        }
+        const completedTransaction = await txBuilder.build();
+        const serializedTx = completedTransaction.toBroadcastFormat();
+        const derivationPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const inputs = [];
+        for (const input of completedTransaction.inputs) {
+            inputs.push({
+                address: input.address,
+                valueString: input.value,
+                value: new BigNumber(input.value).toNumber(),
+            });
+        }
+        const outputs = [];
+        for (const output of completedTransaction.outputs) {
+            outputs.push({
+                address: output.address,
+                valueString: output.value,
+                coinName: output.coin ? output.coin : walletCoin,
+            });
+        }
+        const spendAmount = completedTransaction.inputs.length === 1 ? completedTransaction.inputs[0].value : 0;
+        const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };
+        const feeInfo = { fee: totalFeeForTokenRecovery.toNumber(), feeString: totalFee.toString() };
+        const coinSpecific = { commonKeychain: bitgoKey };
+        if (isUnsignedSweep) {
+            const transaction = {
+                serializedTx: serializedTx,
+                scanIndex: index,
+                coin: walletCoin,
+                signableHex: completedTransaction.signablePayload.toString('hex'),
+                derivationPath: derivationPath,
+                parsedTx: parsedTx,
+                feeInfo: feeInfo,
+                coinSpecific: coinSpecific,
+            };
+            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 a funds recovery transaction without BitGo
+     * @param {SolRecoveryOptions} params parameters needed to construct and
+     * (maybe) sign the transaction
+     *
+     * @returns {BaseBroadcastTransactionResult[]} the serialized transaction hex string and index
+     * of the address being swept
+     */
+    async recoverCloseATA(params) {
+        if (!params.bitgoKey) {
+            throw new Error('missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        if (!params.closeAtaAddress || !this.isValidAddress(params.closeAtaAddress)) {
+            throw new Error('invalid closeAtaAddress');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        // Build the transaction
+        const MPC = await EDDSAMethods.getInitializedMpcInstance();
+        let balance = 0;
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+        const bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();
+        const accountBalance = await this.getAccountBalance(bs58EncodedPublicKey);
+        balance = await this.getAccountBalance(params.closeAtaAddress);
+        if (balance <= 0) {
+            throw Error('Did not find closeAtaAddress with sol funds to recover');
+        }
+        const factory = this.getBuilder();
+        let txBuilder;
+        let blockhash;
+        const recovertTxns = [];
+        const rentExemptAmount = await this.getRentExemptAmount();
+        // do token recovery before closing ATA address
+        // check if any token is present on the closeAtaAddress
+        const tokenInfo = await this.getTokenAccountInfo(params.closeAtaAddress);
+        const tokenBalance = Number(tokenInfo.info.tokenAmount.amount);
+        if (tokenBalance > 0) {
+            // closeATA address has some token balance, it needs to be withdrawn before closing ATA
+            console.log(`closeATA address ${params.closeAtaAddress} has token balance ${tokenBalance}, it needs to be withdrawn before closing ATA address`);
+            if (!params.recoveryDestinationAtaAddress || !this.isValidAddress(params.recoveryDestinationAtaAddress)) {
+                throw new Error('invalid recoveryDestinationAtaAddress');
+            }
+            blockhash = await this.getBlockhash(params.apiKey);
+            txBuilder = factory
+                .getTokenTransferBuilder()
+                .nonce(blockhash)
+                .sender(bs58EncodedPublicKey)
+                .associatedTokenAccountRent(rentExemptAmount.toString())
+                .feePayer(bs58EncodedPublicKey);
+            const unsignedTransaction = (await txBuilder.build());
+            const serializedMessage = unsignedTransaction.solTransaction.serializeMessage().toString('base64');
+            const feePerSignature = await this.getFeeForMessage(serializedMessage, params.apiKey);
+            const baseFee = params.durableNonce ? feePerSignature * 2 : feePerSignature;
+            const totalFee = new BigNumber(baseFee);
+            if (totalFee.gt(accountBalance)) {
+                throw Error('Did not find address with funds to recover');
+            }
+            txBuilder.fee({ amount: feePerSignature });
+            const network = this.getNetwork();
+            const token = getSolTokenFromAddress(tokenInfo.info.mint, network); // todo(WIN-5894) fix for ams
+            txBuilder.send({
+                address: params.recoveryDestinationAtaAddress,
+                amount: tokenBalance,
+                tokenName: token?.name,
+            });
+            const tokenRecoveryTxn = await this.signAndGenerateBroadcastableTransaction(params, txBuilder, bs58EncodedPublicKey);
+            const serializedTokenRecoveryTxn = (await tokenRecoveryTxn).serializedTx;
+            const broadcastTokenRecoveryTxn = await this.broadcastTransaction({
+                serializedSignedTransaction: serializedTokenRecoveryTxn,
+            });
+            logger.log(broadcastTokenRecoveryTxn);
+            recovertTxns.push(broadcastTokenRecoveryTxn);
+        }
+        // after recovering the token amount, attempting to close the ATA address
+        if (params.closeAtaAddress) {
+            blockhash = await this.getBlockhash(params.apiKey);
+            const ataCloseBuilder = () => {
+                const txBuilder = factory.getCloseAtaInitializationBuilder();
+                txBuilder.nonce(blockhash);
+                txBuilder.sender(bs58EncodedPublicKey);
+                txBuilder.accountAddress(params.closeAtaAddress ?? '');
+                txBuilder.destinationAddress(params.recoveryDestination);
+                txBuilder.authorityAddress(bs58EncodedPublicKey);
+                txBuilder.associatedTokenAccountRent(rentExemptAmount.toString());
+                return txBuilder;
+            };
+            txBuilder = ataCloseBuilder();
+        }
+        const closeATARecoveryTxn = await this.signAndGenerateBroadcastableTransaction(params, txBuilder, bs58EncodedPublicKey);
+        const serializedCloseATARecoveryTxn = (await closeATARecoveryTxn).serializedTx;
+        const broadcastCloseATARecoveryTxn = await this.broadcastTransaction({
+            serializedSignedTransaction: serializedCloseATARecoveryTxn,
+        });
+        logger.log(broadcastCloseATARecoveryTxn);
+        recovertTxns.push(broadcastCloseATARecoveryTxn);
+        return recovertTxns;
+    }
+    /**
+     * Recovers tokens from a nested ATA — an ATA whose owner is another ATA rather than a wallet address.
+     *
+     * This situation occurs when an external sender mistakenly calls createAssociatedTokenAccount with
+     * an ATA address as the owner instead of the root wallet address. The result is a "nested ATA"
+     * (ATA-2) owned by the wallet's normal ATA (ATA-1). Because ATA-1 is a PDA with no private key,
+     * the standard recoverCloseATA flow cannot sign for ATA-2.
+     *
+     * This method uses the Associated Token Account program's RecoverNested instruction, which allows
+     * the root wallet owner to sign and atomically move tokens from ATA-2 → ATA-1 and close ATA-2,
+     * returning the rent-exempt SOL to the wallet address.
+     *
+     * @param {SolRecoveryOptions} params - recovery params, requires nestedAtaAddress, ownerAtaAddress,
+     *   and tokenMintAddress in addition to the standard keychain fields
+     */
+    async recoverNestedAta(params) {
+        if (!params.bitgoKey) {
+            throw new Error('missing bitgoKey');
+        }
+        if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {
+            throw new Error('invalid recoveryDestination');
+        }
+        if (!params.nestedAtaAddress || !this.isValidAddress(params.nestedAtaAddress)) {
+            throw new Error('invalid nestedAtaAddress');
+        }
+        if (!params.ownerAtaAddress || !this.isValidAddress(params.ownerAtaAddress)) {
+            throw new Error('invalid ownerAtaAddress');
+        }
+        if (!params.tokenMintAddress || !this.isValidAddress(params.tokenMintAddress)) {
+            throw new Error('invalid tokenMintAddress');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const MPC = await EDDSAMethods.getInitializedMpcInstance();
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);
+        const bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();
+        const blockhash = await this.getBlockhash(params.apiKey);
+        const rentExemptAmount = await this.getRentExemptAmount();
+        const factory = this.getBuilder();
+        const txBuilder = factory.getRecoverNestedAtaBuilder();
+        txBuilder.nonce(blockhash);
+        txBuilder.sender(bs58EncodedPublicKey);
+        txBuilder.feePayer(bs58EncodedPublicKey);
+        txBuilder.associatedTokenAccountRent(rentExemptAmount.toString());
+        txBuilder.nestedAccountAddress(params.nestedAtaAddress);
+        txBuilder.nestedMintAddress(params.tokenMintAddress);
+        txBuilder.destinationAccountAddress(params.ownerAtaAddress);
+        txBuilder.ownerAccountAddress(params.ownerAtaAddress);
+        txBuilder.ownerMintAddress(params.tokenMintAddress);
+        txBuilder.walletAddress(bs58EncodedPublicKey);
+        const recoverNestedTxn = await this.signAndGenerateBroadcastableTransaction(params, txBuilder, bs58EncodedPublicKey);
+        const serializedTxn = (await recoverNestedTxn).serializedTx;
+        const broadcastResult = await this.broadcastTransaction({
+            serializedSignedTransaction: serializedTxn,
+        });
+        logger.log(broadcastResult);
+        return broadcastResult;
+    }
+    async signAndGenerateBroadcastableTransaction(params, txBuilder, bs58EncodedPublicKey) {
+        // Sign the txn
+        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');
+        }
+        const unsignedTransaction = (await txBuilder.build());
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        // Decrypt private keys from KeyCard values
+        let userPrv;
+        try {
+            userPrv = await this.bitgo.decryptAsync({
+                input: userKey,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting user keychain: ${e.message}`);
+        }
+        const userSigningMaterial = JSON.parse(userPrv);
+        let backupPrv;
+        try {
+            backupPrv = await this.bitgo.decryptAsync({
+                input: backupKey,
+                password: params.walletPassphrase,
+            });
+        }
+        catch (e) {
+            throw new Error(`Error decrypting backup keychain: ${e.message}`);
+        }
+        const backupSigningMaterial = JSON.parse(backupPrv);
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const signatureHex = await EDDSAMethods.getTSSSignature(userSigningMaterial, backupSigningMaterial, currPath, unsignedTransaction);
+        const publicKeyObj = { pub: bs58EncodedPublicKey };
+        txBuilder.addSignature(publicKeyObj, signatureHex);
+        const completedTransaction = await txBuilder.build();
+        const serializedTx = completedTransaction.toBroadcastFormat();
+        const transaction = {
+            serializedTx: serializedTx,
+            scanIndex: index,
+        };
+        return transaction;
+    }
+    /**
+     * Builds native SOL 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 {SolConsolidationRecoveryOptions} 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.walletPassphrase;
+        const startIdx = params.startingScanIndex || 1;
+        const endIdx = params.endingScanIndex || startIdx + DEFAULT_SCAN_FACTOR;
+        if (startIdx < 1 || endIdx <= startIdx || endIdx - startIdx > 10 * DEFAULT_SCAN_FACTOR) {
+            throw new Error(`Invalid starting or ending index to scan for addresses. startingScanIndex: ${startIdx}, endingScanIndex: ${endIdx}.`);
+        }
+        // validate durable nonces array
+        if (!params.durableNonces) {
+            throw new Error('Missing durable nonces');
+        }
+        if (!params.durableNonces.publicKeys) {
+            throw new Error('Invalid durable nonces: missing public keys');
+        }
+        if (!params.durableNonces.secretKey) {
+            throw new Error('Invalid durable nonces array: missing secret key');
+        }
+        const bitgoKey = params.bitgoKey.replace(/\s/g, '');
+        const MPC = await EDDSAMethods.getInitializedMpcInstance();
+        const baseAddressIndex = 0;
+        const baseAddressPath = params.seed
+            ? getDerivationPath(params.seed) + `/${baseAddressIndex}`
+            : `m/${baseAddressIndex}`;
+        const accountId = MPC.deriveUnhardened(bitgoKey, baseAddressPath).slice(0, 64);
+        const baseAddress = new SolKeyPair({ pub: accountId }).getAddress();
+        let durableNoncePubKeysIndex = 0;
+        const durableNoncePubKeysLength = params.durableNonces.publicKeys.length;
+        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,
+                durableNonce: {
+                    publicKey: params.durableNonces.publicKeys[durableNoncePubKeysIndex],
+                    secretKey: params.durableNonces.secretKey,
+                },
+                tokenContractAddress: params.tokenContractAddress,
+                apiKey: params.apiKey,
+                programId: params.programId,
+            };
+            let recoveryTransaction;
+            try {
+                recoveryTransaction = await this.recover(recoverParams);
+            }
+            catch (e) {
+                if (e.message === 'Did not find address with funds to recover' ||
+                    e.message === 'Did not find token account to recover tokens, please check token account' ||
+                    e.message === 'Not enough token funds to recover') {
+                    lastScanIndex = i;
+                    continue;
+                }
+                throw e;
+            }
+            if (isUnsignedSweep) {
+                consolidationTransactions.push(recoveryTransaction.txRequests[0]);
+            }
+            else {
+                consolidationTransactions.push(recoveryTransaction);
+            }
+            lastScanIndex = i;
+            durableNoncePubKeysIndex++;
+            if (durableNoncePubKeysIndex >= durableNoncePubKeysLength) {
+                // no more available nonce accounts to create transactions
+                break;
+            }
+        }
+        if (consolidationTransactions.length === 0) {
+            throw new Error('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 = {
+                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 };
+    }
+    getTokenEnablementConfig() {
+        return {
+            requiresTokenEnablement: true,
+            supportsMultipleTokenEnablements: true,
+        };
+    }
+    getBuilder() {
+        return new TransactionBuilderFactory(coins.get(this.getChain()));
+    }
+    async broadcastTransaction({ serializedSignedTransaction, }) {
+        validateRawTransaction(serializedSignedTransaction, true, true);
+        const response = await this.getDataFromNode({
+            payload: {
+                id: '1',
+                jsonrpc: '2.0',
+                method: 'sendTransaction',
+                params: [
+                    serializedSignedTransaction,
+                    {
+                        encoding: 'base64',
+                    },
+                ],
+            },
+        });
+        if (response.body.error) {
+            throw new Error('Error broadcasting transaction: ' + response.body.error.message);
+        }
+        return { txId: response.body.result };
+    }
+    /** @inheritDoc */
+    auditDecryptedKey({ prv, publicKey, multiSigType }) {
+        if (multiSigType !== 'tss') {
+            throw new Error('Unsupported multiSigType');
+        }
+        auditEddsaPrivateKey(prv, publicKey ?? '');
+    }
+    /** @inheritDoc */
+    setCoinSpecificFieldsInIntent(intent, params) {
+        // Handle custom instructions for Solana
+        if (params.solInstructions) {
+            intent.solInstructions = params.solInstructions;
+        }
+        // Handle versioned transaction data for Solana
+        if (params.solVersionedTransactionData) {
+            intent.solVersionedTransactionData = params.solVersionedTransactionData;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sol.js","sourceRoot":"","sources":["../../src/sol.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @prettier\n */\n\nimport { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';\nimport BigNumber from 'bignumber.js';\nimport * as base58 from 'bs58';\nimport * as _ from 'lodash';\nimport * as request from 'superagent';\nimport { logger } from '@bitgo-beta/logger';\n\nimport {\n  AuditDecryptedKeyParams,\n  BaseBroadcastTransactionOptions,\n  BaseBroadcastTransactionResult,\n  BaseCoin,\n  ParseTransactionOptions as BaseParseTransactionOptions,\n  BaseTransaction,\n  TransactionPrebuild as BaseTransactionPrebuild,\n  BitGoBase,\n  EDDSAMethods,\n  EDDSAMethodTypes,\n  Environments,\n  ITokenEnablement,\n  KeyPair,\n  Memo,\n  MPCAlgorithm,\n  MPCConsolidationRecoveryOptions,\n  MPCRecoveryOptions,\n  MPCSweepRecoveryOptions,\n  MPCSweepTxs,\n  MPCTx,\n  MPCTxs,\n  MPCUnsignedTx,\n  MultisigType,\n  multisigTypes,\n  OvcInput,\n  OvcOutput,\n  ParsedTransaction,\n  PopulatedIntent,\n  PrebuildTransactionWithIntentOptions,\n  PresignTransactionOptions,\n  PublicKey,\n  RecoveryTxRequest,\n  SignedTransaction,\n  SignTransactionOptions,\n  SolVersionedTransactionData,\n  TokenEnablement,\n  TokenEnablementConfig,\n  TransactionExplanation,\n  TransactionParams,\n  TransactionRecipient,\n  TransactionType,\n  VerifyTransactionOptions,\n  TssVerifyAddressOptions,\n  verifyEddsaTssWalletAddress,\n  deriveMPCWalletAddress,\n  DeriveAddressOptions,\n  DeriveAddressResult,\n  UnexpectedAddressError,\n  EDDSAUtils,\n} from '@bitgo-beta/sdk-core';\nimport { auditEddsaPrivateKey, deriveUnhardenedMps, getDerivationPath } from '@bitgo-beta/sdk-lib-mpc';\nimport { BaseNetwork, CoinFamily, coins, SolCoin, BaseCoin as StaticsBaseCoin } from '@bitgo-beta/statics';\nimport {\n  KeyPair as SolKeyPair,\n  Transaction,\n  TransactionBuilder,\n  TransactionBuilderFactory,\n  explainSolTransaction,\n} from './lib';\nimport { AtaClose, AtaRecoverNested, TransactionExplanation as SolLibTransactionExplanation } from './lib/iface';\nimport { InstructionBuilderTypes } from './lib/constants';\nimport {\n  getAssociatedTokenAccountAddress,\n  getSolTokenFromAddress,\n  getSolTokenFromTokenName,\n  isValidAddress,\n  isValidPrivateKey,\n  isValidPublicKey,\n  validateRawTransaction,\n} from './lib/utils';\n\nexport const DEFAULT_SCAN_FACTOR = 20; // default number of receive addresses to scan for funds\n\nexport interface TransactionFee {\n  fee: string;\n}\n\nexport type SolTransactionExplanation = TransactionExplanation;\n\nexport interface ExplainTransactionOptions {\n  txBase64: string;\n  feeInfo: TransactionFee;\n  tokenAccountRentExemptAmount?: string;\n  coinName?: string;\n}\n\nexport interface TxInfo {\n  recipients: TransactionRecipient[];\n  from: string;\n  txid: string;\n}\n\nexport interface SolSignTransactionOptions extends SignTransactionOptions {\n  txPrebuild: TransactionPrebuild;\n  prv: string | string[];\n  pubKeys?: string[];\n}\n\nexport interface TransactionPrebuild extends BaseTransactionPrebuild {\n  txBase64: string;\n  txInfo: TxInfo;\n  source: string;\n}\n\nexport interface SolVerifyTransactionOptions extends VerifyTransactionOptions {\n  memo?: Memo;\n  feePayer: string;\n  blockhash: string;\n  durableNonce?: { walletNonceAddress: string; authWalletAddress: number };\n}\n\ninterface TransactionOutput {\n  address: string;\n  amount: number | string;\n  tokenName?: string;\n}\n\ntype TransactionInput = TransactionOutput;\n\nexport interface SolParsedTransaction 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 interface SolParseTransactionOptions extends BaseParseTransactionOptions {\n  txBase64: string;\n  feeInfo: TransactionFee;\n  tokenAccountRentExemptAmount?: string;\n}\n\ninterface SolDurableNonceFromNode {\n  authority: string;\n  blockhash: string;\n}\n\ninterface TokenAmount {\n  amount: string;\n  decimals: number;\n  uiAmount: number;\n  uiAmountString: string;\n}\n\ninterface TokenAccountInfo {\n  isNative: boolean;\n  mint: string;\n  owner: string;\n  state: string;\n  tokenAmount: TokenAmount;\n}\n\ninterface TokenAccount {\n  info: TokenAccountInfo;\n  pubKey: string;\n  tokenName?: string;\n}\n\nexport interface SolRecoveryOptions extends MPCRecoveryOptions {\n  durableNonce?: {\n    publicKey: string;\n    secretKey: string;\n  };\n  tokenContractAddress?: string;\n  closeAtaAddress?: string;\n  // destination address where token should be sent before closing the ATA address\n  recoveryDestinationAtaAddress?: string;\n  // nested ATA address (ATA whose owner is another ATA) to recover tokens from\n  nestedAtaAddress?: string;\n  // the ATA that owns the nested ATA (and where recovered tokens will be sent)\n  ownerAtaAddress?: string;\n  // the token mint address for both ATAs (required when recovering from nested ATA)\n  tokenMintAddress?: string;\n  programId?: string; // programId of the token\n  apiKey?: string; // API key for node requests\n}\n\nexport interface SolConsolidationRecoveryOptions extends MPCConsolidationRecoveryOptions {\n  durableNonces: {\n    publicKeys: string[];\n    secretKey: string;\n  };\n  tokenContractAddress?: string;\n  apiKey?: string; // API key for node requests\n  programId?: string; // programId of the token\n}\n\nconst HEX_REGEX = /^[0-9a-fA-F]+$/;\nconst BLIND_SIGNING_TX_TYPES_TO_CHECK = { enabletoken: 'AssociatedTokenAccountInitialization' };\n\n/**\n * Get amount string corrected for architecture-specific endianness issues.\n *\n * On s390x (big-endian) architecture, the Solana transaction parser (via @solana/web3.js)\n * incorrectly reads little-endian u64 amounts as big-endian, resulting in corrupted values.\n *\n * This function corrects all amounts on s390x by swapping byte order to undo\n * the incorrect byte order that happened during transaction parsing.\n *\n * @param amount - The amount to check and potentially fix\n * @returns The corrected amount as a string\n */\nexport function getAmountBasedOnEndianness(amount: string | number): string {\n  const amountStr = String(amount);\n\n  // Only s390x architecture has this endianness issue\n  const isS390x = process.arch === 's390x';\n  if (!isS390x) {\n    return amountStr;\n  }\n\n  try {\n    const amountBN = BigInt(amountStr);\n    // On s390x, the parser ALWAYS reads u64 as big-endian when it's actually little-endian\n    // So we ALWAYS need to swap bytes to get the correct value\n    const buf = Buffer.alloc(8);\n    buf.writeBigUInt64BE(amountBN, 0);\n    const fixed = buf.readBigUInt64LE(0);\n    return fixed.toString();\n  } catch (e) {\n    // If conversion fails, return original value\n    return amountStr;\n  }\n}\n\nexport class Sol extends BaseCoin {\n  protected readonly _staticsCoin: Readonly<StaticsBaseCoin>;\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  static createInstance(bitgo: BitGoBase, staticsCoin?: Readonly<StaticsBaseCoin>): BaseCoin {\n    return new Sol(bitgo, staticsCoin);\n  }\n\n  allowsAccountConsolidations(): boolean {\n    return true;\n  }\n\n  supportsTss(): boolean {\n    return true;\n  }\n\n  /** @inheritDoc */\n  supportsMessageSigning(): 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  getChain(): string {\n    return this._staticsCoin.name;\n  }\n\n  getFamily(): CoinFamily {\n    return this._staticsCoin.family;\n  }\n\n  getFullName(): string {\n    return this._staticsCoin.fullName;\n  }\n\n  getNetwork(): BaseNetwork {\n    return this._staticsCoin.network;\n  }\n\n  getBaseFactor(): string | number {\n    return Math.pow(10, this._staticsCoin.decimalPlaces);\n  }\n\n  verifyTxType(expectedTypeFromUserParams: string, actualTypeFromDecoded: string | undefined): void {\n    const matchFromUserToDecodedType = BLIND_SIGNING_TX_TYPES_TO_CHECK[expectedTypeFromUserParams];\n    if (matchFromUserToDecodedType !== actualTypeFromDecoded) {\n      throw new Error(\n        `Invalid transaction type on token enablement: expected \"${matchFromUserToDecodedType}\", got \"${actualTypeFromDecoded}\".`\n      );\n    }\n  }\n\n  throwIfMissingTokenEnablementsOrReturn(explanation: TransactionExplanation): ITokenEnablement[] {\n    if (!explanation.tokenEnablements || explanation.tokenEnablements.length === 0)\n      throw new Error('Missing tx token enablements data on token enablement tx prebuild');\n    return explanation.tokenEnablements;\n  }\n\n  throwIfMissingEnableTokenConfigOrReturn(txParams: TransactionParams): TokenEnablement[] {\n    if (!txParams.enableTokens || txParams.enableTokens.length === 0) throw new Error('Missing enable token config');\n    return txParams.enableTokens;\n  }\n\n  verifyTokenName(tokenEnablementsPrebuild: ITokenEnablement[], enableTokensConfig: TokenEnablement[]): void {\n    enableTokensConfig.forEach((enableTokenConfig) => {\n      const expectedTokenName = enableTokenConfig.name;\n      tokenEnablementsPrebuild.forEach((tokenEnablement) => {\n        if (!tokenEnablement.tokenName) throw new Error('Missing token name on token enablement tx');\n        if (tokenEnablement.tokenName !== expectedTokenName)\n          throw new Error(\n            `Invalid token name: expected ${expectedTokenName}, got ${tokenEnablement.tokenName} on token enablement tx`\n          );\n      });\n    });\n  }\n\n  async verifyTokenAddress(\n    tokenEnablementsPrebuild: ITokenEnablement[],\n    enableTokensConfig: TokenEnablement[]\n  ): Promise<void> {\n    for (const enableTokenConfig of enableTokensConfig) {\n      const expectedTokenAddress = enableTokenConfig.address;\n      const expectedTokenName = enableTokenConfig.name;\n\n      if (!expectedTokenAddress) throw new Error('Missing token address on token enablement tx');\n      if (!expectedTokenName) throw new Error('Missing token name on token enablement tx');\n\n      for (const tokenEnablement of tokenEnablementsPrebuild) {\n        let tokenMintAddress: Readonly<SolCoin> | undefined;\n        try {\n          tokenMintAddress = getSolTokenFromTokenName(expectedTokenName);\n        } catch {\n          throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`);\n        }\n        if (\n          !tokenMintAddress ||\n          tokenMintAddress.tokenAddress === undefined ||\n          tokenMintAddress.programId === undefined\n        ) {\n          throw new Error(`Unable to get token mint address for ${expectedTokenName}`);\n        }\n        let ata: string;\n        try {\n          ata = await getAssociatedTokenAccountAddress(\n            tokenMintAddress.tokenAddress,\n            expectedTokenAddress,\n            true,\n            tokenMintAddress.programId\n          );\n        } catch {\n          throw new Error(`Unable to derive ATA for token address: ${expectedTokenAddress}`);\n        }\n        if (ata !== tokenEnablement.address) {\n          throw new Error(\n            `Invalid token address: expected ${ata}, got ${tokenEnablement.address} on token enablement tx`\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * For transactions typed as `CloseAssociatedTokenAccount` (includes SPL close-account and\n   * recover-nested flows), enforce that rent / authority aligns with the wallet root when known.\n   *\n   * No-op when `walletRootAddress` is not provided (e.g. uninitialized wallets).\n   */\n  private verifyCloseAssociatedTokenAccountFamilyRoots(\n    transaction: Transaction,\n    walletRootAddress: string | undefined\n  ): void {\n    if (!walletRootAddress) {\n      return;\n    }\n\n    const txJson = transaction.toJson();\n\n    for (const instruction of txJson.instructionsData) {\n      if (instruction.type === InstructionBuilderTypes.CloseAssociatedTokenAccount) {\n        const closeInstruction = instruction as AtaClose;\n        if (closeInstruction.params.destinationAddress !== walletRootAddress) {\n          throw new Error(\n            `Close ATA destination must be wallet root address. Expected ${walletRootAddress}, got ${closeInstruction.params.destinationAddress}`\n          );\n        }\n      } else if (instruction.type === InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount) {\n        const recoverNestedInstruction = instruction as AtaRecoverNested;\n        if (recoverNestedInstruction.params.walletAddress !== walletRootAddress) {\n          throw new Error(\n            `Recover nested wallet address must be wallet root address. Expected ${walletRootAddress}, got ${recoverNestedInstruction.params.walletAddress}`\n          );\n        }\n      }\n    }\n  }\n\n  /**\n   * When the caller supplies `recipients` for a close-ATA prebuild, require they match the\n   * on-chain ATA accounts being closed (order-independent) and carry zero amount (intent-only).\n   * Recover-nested-only txs have no close instructions; this is a no-op in that case.\n   */\n  private verifyCloseAtaRecipientsMatchCloseInstructions(\n    transaction: Transaction,\n    recipients: TransactionRecipient[]\n  ): void {\n    const txJson = transaction.toJson();\n    const closeAtaAccountAddresses = txJson.instructionsData\n      .filter((inst) => inst.type === InstructionBuilderTypes.CloseAssociatedTokenAccount)\n      .map((inst) => (inst as AtaClose).params.accountAddress);\n\n    if (closeAtaAccountAddresses.length === 0) {\n      return;\n    }\n\n    for (const recipient of recipients) {\n      if (recipient.tokenName) {\n        throw new Error('Close ATA recipients must not specify tokenName');\n      }\n      if (!new BigNumber(String(recipient.amount ?? '0')).isZero()) {\n        throw new Error('Close ATA recipients must have zero amount');\n      }\n    }\n\n    const sortedRecipients = [...recipients.map((r) => r.address)].sort();\n    const sortedCloses = [...closeAtaAccountAddresses].sort();\n    if (!_.isEqual(sortedRecipients, sortedCloses)) {\n      throw new Error(\n        'Close ATA txParams.recipients addresses must match the ATA account addresses in the transaction instructions'\n      );\n    }\n  }\n\n  private hasSolVersionedTransactionData(\n    txParams: TransactionParams\n  ): txParams is TransactionParams & { solVersionedTransactionData: SolVersionedTransactionData } {\n    return 'solVersionedTransactionData' in txParams && txParams.solVersionedTransactionData !== undefined;\n  }\n\n  /**\n   * Verify a versioned Solana transaction with basic structural validation\n   * @param params - verification parameters\n   * @returns true if verification passes\n   */\n  private async verifyVersionedTransaction(params: SolVerifyTransactionOptions): Promise<boolean> {\n    const { txParams, txPrebuild } = params;\n    const rawTx = txPrebuild.txBase64 || txPrebuild.txHex;\n\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txBase64 or txHex');\n    }\n\n    // Validate that the versioned transaction data is well-formed\n    if (!this.hasSolVersionedTransactionData(txParams)) {\n      throw new Error('solVersionedTransactionData is required for versioned transaction verification');\n    }\n\n    const versionedData = txParams.solVersionedTransactionData;\n\n    if (!versionedData.versionedInstructions || versionedData.versionedInstructions.length === 0) {\n      throw new Error('versioned transaction must have at least one instruction');\n    }\n\n    if (!versionedData.staticAccountKeys || versionedData.staticAccountKeys.length === 0) {\n      throw new Error('versioned transaction must have at least one static account key');\n    }\n\n    if (!versionedData.messageHeader) {\n      throw new Error('versioned transaction must have a message header');\n    }\n\n    // Validate that we can deserialize the transaction\n    let rawTxBase64 = rawTx;\n    if (HEX_REGEX.test(rawTx)) {\n      rawTxBase64 = Buffer.from(rawTx, 'hex').toString('base64');\n    }\n\n    try {\n      const txBytes = Buffer.from(rawTxBase64, 'base64');\n      if (txBytes.length < 1) {\n        throw new Error('transaction bytes are empty');\n      }\n\n      // Check version byte (after signatures)\n      const numSignatures = txBytes[0];\n      const signatureSize = 64;\n      const versionByteOffset = 1 + numSignatures * signatureSize;\n\n      if (txBytes.length <= versionByteOffset) {\n        throw new Error('transaction bytes are too short to contain version byte');\n      }\n\n      const versionByte = txBytes[versionByteOffset];\n      const isVersioned = (versionByte & 0x80) !== 0;\n\n      if (!isVersioned) {\n        throw new Error('transaction does not have versioned format');\n      }\n    } catch (error) {\n      throw new Error(`failed to validate versioned transaction format: ${error.message}`);\n    }\n\n    return true;\n  }\n\n  async verifyTransaction(params: SolVerifyTransactionOptions): Promise<boolean> {\n    // asset name to transfer amount map\n    const totalAmount: Record<string, BigNumber> = {};\n    const coinConfig = coins.get(this.getChain());\n    const {\n      txParams: txParams,\n      txPrebuild: txPrebuild,\n      memo: memo,\n      durableNonce: durableNonce,\n      verification: verificationOptions,\n    } = params;\n\n    if (this.hasSolVersionedTransactionData(txParams)) {\n      return this.verifyVersionedTransaction(params);\n    }\n\n    const transaction = new Transaction(coinConfig);\n    const rawTx = txPrebuild.txBase64 || txPrebuild.txHex;\n    const consolidateId = txPrebuild.consolidateId;\n\n    const walletRootAddress = params.wallet.coinSpecific()?.rootAddress;\n\n    if (!rawTx) {\n      throw new Error('missing required tx prebuild property txBase64 or txHex');\n    }\n\n    let rawTxBase64 = rawTx;\n    if (HEX_REGEX.test(rawTx)) {\n      rawTxBase64 = Buffer.from(rawTx, 'hex').toString('base64');\n    }\n    transaction.fromRawTransaction(rawTxBase64);\n    const explainedTx = transaction.explainTransaction();\n    const isCloseAssociatedTokenAccountTx = transaction.type === TransactionType.CloseAssociatedTokenAccount;\n\n    if (txParams.type === 'enabletoken' && verificationOptions?.verifyTokenEnablement) {\n      this.verifyTxType(txParams.type, explainedTx.type);\n      const tokenEnablementsPrebuild = this.throwIfMissingTokenEnablementsOrReturn(explainedTx);\n      const enableTokensConfig = this.throwIfMissingEnableTokenConfigOrReturn(txParams);\n\n      this.verifyTokenName(tokenEnablementsPrebuild, enableTokensConfig);\n      await this.verifyTokenAddress(tokenEnablementsPrebuild, enableTokensConfig);\n    }\n\n    if (isCloseAssociatedTokenAccountTx) {\n      this.verifyCloseAssociatedTokenAccountFamilyRoots(transaction, walletRootAddress);\n      if (txParams.recipients !== undefined) {\n        this.verifyCloseAtaRecipientsMatchCloseInstructions(transaction, txParams.recipients);\n      }\n    }\n\n    const isTokenEnablementTx = txParams.type === 'enabletoken';\n    // users do not input recipients for consolidation requests as they are generated by the server\n    // Close-ATA txs do not populate explainedTx.outputs; recipients carry ATA addresses for intent only.\n    if (txParams.recipients !== undefined && !isTokenEnablementTx && !isCloseAssociatedTokenAccountTx) {\n      const filteredRecipients = txParams.recipients?.map((recipient) =>\n        _.pick(recipient, ['address', 'amount', 'tokenName'])\n      );\n      const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));\n\n      if (filteredRecipients.length !== filteredOutputs.length) {\n        throw new Error('Number of tx outputs does not match with number of txParams recipients');\n      }\n\n      // For each recipient, check if it's a token tx (tokenName will exist if so)\n      // If it is a token tx, verify that the recipient address equals the derived address from explainedTx\n      // Derive the ATA if it is a native address and confirm it is equal to the explained tx recipient\n      const recipientChecks = await Promise.all(\n        filteredRecipients.map(async (recipientFromUser, index) => {\n          const recipientFromTx = filteredOutputs[index]; // This address should be an ATA\n\n          // Compare the BigNumber values because amount is (string | number)\n          // Apply s390x endianness fix if needed\n          const userAmountStr = String(recipientFromUser.amount);\n          const txAmountStr = getAmountBasedOnEndianness(recipientFromTx.amount);\n\n          const userAmount = new BigNumber(userAmountStr);\n          const txAmount = new BigNumber(txAmountStr);\n          if (!userAmount.isEqualTo(txAmount)) {\n            return false;\n          }\n\n          // Compare the addresses and tokenNames\n          // Else if the addresses are not the same, check the derived ATA for parity\n          if (\n            recipientFromUser.address === recipientFromTx.address &&\n            recipientFromUser.tokenName === recipientFromTx.tokenName\n          ) {\n            return true;\n          } else if (recipientFromUser.address !== recipientFromTx.address && recipientFromUser.tokenName) {\n            // Try to check if the user's derived ATA is equal to the tx recipient address\n            // If getAssociatedTokenAccountAddress throws an error, then we are unable to derive the ATA for that address.\n            // Return false and throw an error if that is the case.\n            try {\n              const tokenMintAddress = getSolTokenFromTokenName(recipientFromUser.tokenName);\n              return getAssociatedTokenAccountAddress(\n                tokenMintAddress!.tokenAddress,\n                recipientFromUser.address,\n                true,\n                tokenMintAddress!.programId\n              ).then((ata: string) => {\n                return ata === recipientFromTx.address;\n              });\n            } catch {\n              // Unable to derive ATA\n              return false;\n            }\n          }\n          return false;\n        })\n      );\n\n      if (recipientChecks.includes(false)) {\n        throw new Error('Tx outputs does not match with expected txParams recipients');\n      }\n    } else if (verificationOptions?.consolidationToBaseAddress) {\n      //verify funds are sent to walletRootAddress for a consolidation\n      const filteredOutputs = explainedTx.outputs.map((output) => _.pick(output, ['address', 'amount', 'tokenName']));\n\n      // Cache to store already derived ATA addresses\n      const ataAddressCache: Record<string, string> = {};\n\n      for (const output of filteredOutputs) {\n        if (output.tokenName) {\n          // Check cache first before deriving ATA address\n          if (!ataAddressCache[output.tokenName]) {\n            const tokenMintAddress = getSolTokenFromTokenName(output.tokenName);\n            if (tokenMintAddress?.tokenAddress && tokenMintAddress?.programId) {\n              ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(\n                tokenMintAddress.tokenAddress,\n                walletRootAddress as string,\n                true,\n                tokenMintAddress.programId\n              );\n            } else {\n              throw new Error(`Unable to get token information for ${output.tokenName}`);\n            }\n          }\n\n          if (ataAddressCache[output.tokenName] !== output.address) {\n            throw new Error('tx outputs does not match with expected address');\n          }\n        } else if (output.address !== walletRootAddress) {\n          throw new Error('tx outputs does not match with expected address');\n        }\n      }\n    }\n\n    const transactionJson = transaction.toJson();\n    if (memo && memo.value !== explainedTx.memo) {\n      throw new Error('Tx memo does not match with expected txParams recipient memo');\n    }\n    if (txParams.recipients && !isTokenEnablementTx && !isCloseAssociatedTokenAccountTx) {\n      for (const recipients of txParams.recipients) {\n        // totalAmount based on each token\n        const assetName = recipients.tokenName || this.getChain();\n        const amount = totalAmount[assetName] || new BigNumber(0);\n        totalAmount[assetName] = amount.plus(recipients.amount);\n      }\n\n      // total output amount from explainedTx\n      const explainedTxTotal: Record<string, BigNumber> = {};\n\n      for (const output of explainedTx.outputs) {\n        // Apply s390x endianness fix to output amounts before summing\n        const outputAmountStr = getAmountBasedOnEndianness(output.amount);\n\n        // total output amount based on each token\n        const assetName = output.tokenName || this.getChain();\n        const amount = explainedTxTotal[assetName] || new BigNumber(0);\n        explainedTxTotal[assetName] = amount.plus(outputAmountStr);\n      }\n\n      if (!_.isEqual(explainedTxTotal, totalAmount)) {\n        throw new Error('Tx total amount does not match with expected total amount field');\n      }\n    }\n\n    // For non-consolidate transactions, feePayer must be the wallet's root address\n    if (consolidateId === undefined && transactionJson.feePayer !== walletRootAddress) {\n      throw new Error('Tx fee payer is not the wallet root address');\n    }\n\n    if (durableNonce && !_.isEqual(explainedTx.durableNonce, durableNonce)) {\n      throw new Error('Tx durableNonce does not match with param durableNonce');\n    }\n\n    return true;\n  }\n\n  async isWalletAddress(params: TssVerifyAddressOptions): Promise<boolean> {\n    const result = await verifyEddsaTssWalletAddress(\n      params,\n      (address) => this.isValidAddress(address),\n      (publicKey) => this.getAddressFromPublicKey(publicKey)\n    );\n\n    if (!result) {\n      throw new UnexpectedAddressError(`address validation failure: ${params.address} is not a wallet address`);\n    }\n\n    return true;\n  }\n\n  /**\n   * Locally derive a SOL wallet receive address from a derivation path, using the wallet's\n   * commonKeychain only (no private keys, no network access). This is the inverse of\n   * {@link isWalletAddress}: it *produces* the address via the same EdDSA TSS derivation that\n   * isWalletAddress checks against, so the two can never diverge.\n   * @param params keychains (commonKeychain), derivation index, and optional SMC seed\n   * @returns the derived address, the index used, and the HD derivation path\n   */\n  async deriveAddress(params: DeriveAddressOptions): Promise<DeriveAddressResult> {\n    const { address, derivationPath } = await deriveMPCWalletAddress(\n      {\n        // extractCommonKeychain validates the commonKeychain is present at runtime\n        keychains: (params.keychains ?? []) as TssVerifyAddressOptions['keychains'],\n        index: params.index,\n        derivedFromParentWithSeed: params.derivedFromParentWithSeed,\n        multisigTypeVersion: params.multisigTypeVersion,\n        keyCurve: 'ed25519',\n      },\n      (publicKey) => this.getAddressFromPublicKey(publicKey)\n    );\n\n    return { address, index: params.index, derivationPath };\n  }\n\n  /**\n   * Converts a Solana public key to an address\n   * @param publicKey Hex-encoded public key (64 hex characters = 32 bytes)\n   * @returns Base58-encoded Solana address\n   */\n  getAddressFromPublicKey(publicKey: string): string {\n    const publicKeyBuffer = Buffer.from(publicKey, 'hex');\n    return base58.encode(publicKeyBuffer);\n  }\n\n  /**\n   * Generate Solana key pair\n   *\n   * @param {Buffer} seed - Seed from which the new SolKeyPair should be generated, otherwise a random seed is used\n   * @returns {Object} object with generated pub and prv\n   */\n  generateKeyPair(seed?: Buffer | undefined): KeyPair {\n    const result = seed ? new SolKeyPair({ seed }).getKeys() : new SolKeyPair().getKeys();\n    return result as KeyPair;\n  }\n\n  /**\n   * Return boolean indicating whether input is valid public key for the coin\n   *\n   * @param {string} pub the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPub(pub: string): boolean {\n    return isValidPublicKey(pub);\n  }\n\n  /**\n   * Return boolean indicating whether input is valid private key for the coin\n   *\n   * @param {string} prv the prv to be checked\n   * @returns is it valid?\n   */\n  isValidPrv(prv: string): boolean {\n    return isValidPrivateKey(prv);\n  }\n\n  isValidAddress(address: string): boolean {\n    return isValidAddress(address);\n  }\n\n  async signMessage(key: KeyPair, message: string | Buffer): Promise<Buffer> {\n    const solKeypair = new SolKeyPair({ prv: key.prv });\n    if (Buffer.isBuffer(message)) {\n      message = base58.encode(message);\n    }\n\n    return Buffer.from(solKeypair.signMessage(message));\n  }\n\n  /**\n   * Signs Solana transaction\n   * @param params\n   * @param callback\n   */\n  async signTransaction(params: SolSignTransactionOptions): Promise<SignedTransaction> {\n    const factory = this.getBuilder();\n    const rawTx = params.txPrebuild.txHex || params.txPrebuild.txBase64;\n    const txBuilder = factory.from(rawTx);\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  async parseTransaction(params: SolParseTransactionOptions): Promise<SolParsedTransaction> {\n    // explainTransaction now uses WASM for testnet automatically\n    const transactionExplanation = await this.explainTransaction({\n      txBase64: params.txBase64,\n      feeInfo: params.feeInfo,\n      tokenAccountRentExemptAmount: params.tokenAccountRentExemptAmount,\n    });\n\n    if (!transactionExplanation) {\n      throw new Error('Invalid transaction');\n    }\n\n    const solTransaction = transactionExplanation as SolTransactionExplanation;\n    if (solTransaction.outputs.length <= 0) {\n      return {\n        inputs: [],\n        outputs: [],\n      };\n    }\n\n    const senderAddress = solTransaction.outputs[0].address;\n    const feeAmount = new BigNumber(solTransaction.fee.fee);\n\n    // assume 1 sender, who is also the fee payer\n    const inputs = [\n      {\n        address: senderAddress,\n        amount: new BigNumber(solTransaction.outputAmount).plus(feeAmount).toNumber(),\n      },\n    ];\n\n    const outputs: TransactionOutput[] = solTransaction.outputs.map(({ address, amount, tokenName }) => {\n      const output: TransactionOutput = { address, amount };\n      if (tokenName) {\n        output.tokenName = tokenName;\n      }\n      return output;\n    });\n\n    return {\n      inputs,\n      outputs,\n    };\n  }\n\n  /**\n   * Explain a Solana transaction from txBase64\n   * Uses WASM-based parsing for testnet, with fallback to legacy builder approach.\n   * @param params\n   */\n  async explainTransaction(params: ExplainTransactionOptions): Promise<SolTransactionExplanation> {\n    // Use WASM-based parsing for testnet (simpler, faster, no @solana/web3.js rebuild)\n    if (this.getChain() === 'tsol') {\n      return this.explainTransactionWithWasm(params) as SolTransactionExplanation;\n    }\n\n    // Legacy approach for mainnet (until WASM is fully validated)\n    const factory = this.getBuilder();\n    let rebuiltTransaction;\n\n    try {\n      const transactionBuilder = factory.from(params.txBase64);\n      if (transactionBuilder instanceof TransactionBuilder) {\n        const txBuilder = transactionBuilder as TransactionBuilder;\n        txBuilder.fee({ amount: params.feeInfo.fee });\n        if (params.tokenAccountRentExemptAmount) {\n          txBuilder.associatedTokenAccountRent(params.tokenAccountRentExemptAmount);\n        }\n      }\n      rebuiltTransaction = await transactionBuilder.build();\n    } catch (e) {\n      logger.error(e);\n      throw new Error('Invalid transaction');\n    }\n\n    const explainedTransaction = (rebuiltTransaction as BaseTransaction).explainTransaction();\n\n    return explainedTransaction as SolTransactionExplanation;\n  }\n\n  /**\n   * Explain a Solana transaction using WASM parsing (bypasses @solana/web3.js rebuild).\n   * Delegates to standalone explainSolTransaction().\n   */\n  explainTransactionWithWasm(params: ExplainTransactionOptions): SolLibTransactionExplanation {\n    return explainSolTransaction({ ...params, coinName: params.coinName ?? this.getChain() });\n  }\n\n  /** @inheritDoc */\n  async getSignablePayload(serializedTx: string): Promise<Buffer> {\n    const factory = this.getBuilder();\n    const rebuiltTransaction = await factory.from(serializedTx).build();\n    return rebuiltTransaction.signablePayload;\n  }\n\n  /** @inheritDoc */\n  async presignTransaction(params: PresignTransactionOptions): Promise<PresignTransactionOptions> {\n    // Hot wallet txns are only valid for 1-2 minutes.\n    // To buy more time, we rebuild the transaction with a new blockhash right before we sign.\n    if (params.walletData.type !== 'hot') {\n      return Promise.resolve(params);\n    }\n\n    const txRequestId = params.txPrebuild?.txRequestId;\n    if (txRequestId === undefined) {\n      throw new Error('Missing txRequestId');\n    }\n\n    const { tssUtils } = params;\n\n    await tssUtils!.deleteSignatureShares(txRequestId);\n    const recreated = await tssUtils!.getTxRequest(txRequestId);\n    let txHex = '';\n    if (recreated.unsignedTxs) {\n      txHex = recreated.unsignedTxs[0]?.serializedTxHex;\n    } else {\n      txHex = recreated.transactions ? recreated.transactions[0]?.unsignedTx.serializedTxHex : '';\n    }\n\n    if (!txHex) {\n      throw new Error('Missing serialized tx hex');\n    }\n\n    return Promise.resolve({\n      ...params,\n      txPrebuild: recreated,\n      txHex,\n    });\n  }\n\n  protected getPublicNodeUrl(apiKey?: string): string {\n    if (apiKey) {\n      return Environments[this.bitgo.getEnv()].solAlchemyNodeUrl + `/${apiKey}`;\n    }\n    return Environments[this.bitgo.getEnv()].solNodeUrl;\n  }\n\n  /**\n   * Make a request to one of the public SOL nodes available\n   * @param params.payload\n   */\n  protected async getDataFromNode(\n    params: { payload?: Record<string, unknown> },\n    apiKey?: string\n  ): Promise<request.Response> {\n    const nodeUrl = this.getPublicNodeUrl(apiKey);\n    try {\n      return await request.post(nodeUrl).send(params.payload);\n    } catch (e) {\n      console.debug(e);\n    }\n    throw new Error(`Unable to call endpoint: '/' from node: ${nodeUrl}`);\n  }\n\n  protected async getBlockhash(apiKey?: string): Promise<string> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getLatestBlockhash',\n          params: [\n            {\n              commitment: 'finalized',\n            },\n          ],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n\n    return response.body.result.value.blockhash;\n  }\n\n  protected async getFeeForMessage(message: string, apiKey?: string): Promise<number> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getFeeForMessage',\n          params: [\n            message,\n            {\n              commitment: 'finalized',\n            },\n          ],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n\n    return response.body.result.value;\n  }\n\n  protected async getRentExemptAmount(apiKey?: string): Promise<number> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          jsonrpc: '2.0',\n          id: '1',\n          method: 'getMinimumBalanceForRentExemption',\n          params: [165],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200 || response.error) {\n      throw new Error(JSON.stringify(response.error));\n    }\n\n    return response.body.result;\n  }\n\n  protected async getAccountBalance(pubKey: string, apiKey?: string): Promise<number> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getBalance',\n          params: [pubKey],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    return response.body.result.value;\n  }\n\n  protected async getAccountInfo(pubKey: string, apiKey?: string): Promise<SolDurableNonceFromNode> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getAccountInfo',\n          params: [\n            pubKey,\n            {\n              encoding: 'jsonParsed',\n            },\n          ],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    return {\n      authority: response.body.result.value.data.parsed.info.authority,\n      blockhash: response.body.result.value.data.parsed.info.blockhash,\n    };\n  }\n\n  protected async getTokenAccountsByOwner(pubKey = '', programId = '', apiKey?: string): Promise<[] | TokenAccount[]> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getTokenAccountsByOwner',\n          params: [\n            pubKey,\n            {\n              programId:\n                programId.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()\n                  ? TOKEN_2022_PROGRAM_ID.toString()\n                  : TOKEN_PROGRAM_ID.toString(),\n            },\n            {\n              encoding: 'jsonParsed',\n            },\n          ],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n\n    if (response.body.result.value.length !== 0) {\n      const tokenAccounts: TokenAccount[] = [];\n      for (const tokenAccount of response.body.result.value) {\n        tokenAccounts.push({ info: tokenAccount.account.data.parsed.info, pubKey: tokenAccount.pubKey });\n      }\n      return tokenAccounts;\n    }\n\n    return [];\n  }\n\n  protected async getTokenAccountInfo(pubKey: string, apiKey?: string): Promise<TokenAccount> {\n    const response = await this.getDataFromNode(\n      {\n        payload: {\n          id: '1',\n          jsonrpc: '2.0',\n          method: 'getAccountInfo',\n          params: [\n            pubKey,\n            {\n              encoding: 'jsonParsed',\n            },\n          ],\n        },\n      },\n      apiKey\n    );\n    if (response.status !== 200) {\n      throw new Error('Account not found');\n    }\n    return {\n      pubKey: pubKey,\n      info: response.body.result.value.data.parsed.info,\n    };\n  }\n\n  /** inherited doc */\n  async createBroadcastableSweepTransaction(params: MPCSweepRecoveryOptions): Promise<MPCTxs> {\n    if (!params.signatureShares) {\n      ('Missing transaction(s)');\n    }\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      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      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      const signatureHex = Buffer.concat([Buffer.from(signature.R, 'hex'), Buffer.from(signature.sigma, 'hex')]);\n      const txBuilder = this.getBuilder().from(transaction.serializedTx as string);\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 bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();\n\n      // add combined signature from ovc\n      const publicKeyObj = { pub: bs58EncodedPublicKey };\n      txBuilder.addSignature(publicKeyObj as PublicKey, signatureHex);\n\n      const signedTransaction = await txBuilder.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\n    return { transactions: broadcastableTransactions, lastScanIndex };\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param {SolRecoveryOptions} params parameters needed to construct and\n   * (maybe) sign the transaction\n   *\n   * @returns {MPCTx | MPCSweepTxs} the serialized transaction hex string and index\n   * of the address being swept\n   */\n  async recover(params: SolRecoveryOptions): Promise<MPCTx | MPCSweepTxs> {\n    if (!params.bitgoKey) {\n      throw new Error('missing bitgoKey');\n    }\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.walletPassphrase;\n\n    // Validate signing keys and detect MPCv2 format early for signed recovery\n    let isMpcV2 = false;\n    if (params.walletPassphrase) {\n      if (!params.userKey) {\n        throw new Error('missing userKey');\n      }\n      if (!params.backupKey) {\n        throw new Error('missing backupKey');\n      }\n      // Detect MPCv2 keycards — will throw if decryption fails (e.g., wrong password).\n      // MPCv1 keycards decrypt to JSON with uShare/bitgoYShare; MPCv2 keycards are CBOR.\n      try {\n        const isV1 = await EDDSAUtils.EddsaMPCv2RecoveryFunctions.isEddsaMpcV1SigningMaterial(\n          params.userKey.replace(/\\s/g, ''),\n          params.walletPassphrase,\n          this.bitgo\n        );\n        isMpcV2 = !isV1;\n      } catch (e) {\n        // Re-wrap decryption errors with context\n        throw new Error(`Error decrypting user keychain: ${e instanceof Error ? e.message : String(e)}`);\n      }\n    }\n\n    let balance = 0;\n\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n\n    let accountId: string;\n    if (isMpcV2) {\n      accountId = deriveUnhardenedMps(bitgoKey, currPath).slice(0, 64);\n    } else {\n      const MPC = await EDDSAMethods.getInitializedMpcInstance();\n      accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);\n    }\n    const bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();\n\n    balance = await this.getAccountBalance(bs58EncodedPublicKey, params.apiKey);\n\n    const factory = this.getBuilder();\n    const walletCoin = this.getChain();\n\n    let txBuilder;\n    let blockhash = await this.getBlockhash(params.apiKey);\n    let rentExemptAmount;\n    let authority = '';\n    let totalFee = new BigNumber(0);\n    let totalFeeForTokenRecovery = new BigNumber(0);\n\n    // check for possible token recovery, recover the token provide by user\n    if (params.tokenContractAddress) {\n      let isUnsupportedToken = false;\n      const tokenAccounts = await this.getTokenAccountsByOwner(bs58EncodedPublicKey, params.programId, params.apiKey);\n      if (tokenAccounts.length !== 0) {\n        // there exists token accounts on the given address, but need to check certain conditions:\n        // 1. if there is a recoverable balance\n        // 2. if the token is supported by bitgo\n        const recovereableTokenAccounts: TokenAccount[] = [];\n        for (const tokenAccount of tokenAccounts) {\n          if (params.tokenContractAddress === tokenAccount.info.mint) {\n            const tokenAmount = new BigNumber(tokenAccount.info.tokenAmount.amount);\n            const network = this.getNetwork();\n            const token = getSolTokenFromAddress(tokenAccount.info.mint, network); // todo(WIN-5894) fix for ams\n\n            if (!token) {\n              isUnsupportedToken = true;\n            }\n            if (tokenAmount.gt(new BigNumber(0))) {\n              tokenAccount.tokenName = token?.name || 'Unsupported Token';\n              recovereableTokenAccounts.push(tokenAccount);\n            }\n            break;\n          }\n        }\n\n        if (recovereableTokenAccounts.length !== 0) {\n          rentExemptAmount = await this.getRentExemptAmount(params.apiKey);\n\n          txBuilder = factory\n            .getTokenTransferBuilder()\n            .nonce(blockhash)\n            .sender(bs58EncodedPublicKey)\n            .associatedTokenAccountRent(rentExemptAmount.toString())\n            .feePayer(bs58EncodedPublicKey);\n\n          // need to get all token accounts of the recipient address and need to create them if they do not exist\n          const recipientTokenAccounts = await this.getTokenAccountsByOwner(\n            params.recoveryDestination,\n            params.programId,\n            params.apiKey\n          );\n\n          for (const tokenAccount of recovereableTokenAccounts) {\n            let recipientTokenAccountExists = false;\n            for (const recipientTokenAccount of recipientTokenAccounts as TokenAccount[]) {\n              if (recipientTokenAccount.info.mint === tokenAccount.info.mint) {\n                recipientTokenAccountExists = true;\n                break;\n              }\n            }\n\n            const recipientTokenAccount = await getAssociatedTokenAccountAddress(\n              tokenAccount.info.mint,\n              params.recoveryDestination,\n              false,\n              params.programId?.toString()\n            );\n            const tokenName = tokenAccount.tokenName as string;\n            const sendParams = {\n              address: recipientTokenAccount,\n              amount: tokenAccount.info.tokenAmount.amount,\n              tokenName,\n              ...(isUnsupportedToken\n                ? {\n                    tokenAddress: tokenAccount.info.mint,\n                    programId: params.programId?.toString(),\n                    decimalPlaces: tokenAccount.info.tokenAmount.decimals,\n                  }\n                : {}),\n            };\n            txBuilder.send(sendParams);\n\n            if (!recipientTokenAccountExists) {\n              // recipient token account does not exist for token and must be created\n              txBuilder.createAssociatedTokenAccount({\n                ownerAddress: params.recoveryDestination,\n                tokenName: tokenName,\n                ...(isUnsupportedToken ? { tokenAddress: tokenAccount.info.mint } : {}),\n                programId:\n                  params.programId?.toString().toLowerCase() === TOKEN_2022_PROGRAM_ID.toString().toLowerCase()\n                    ? TOKEN_2022_PROGRAM_ID.toString()\n                    : TOKEN_PROGRAM_ID.toString(),\n              });\n              // add rent exempt amount to total fee for each token account that has to be created\n              totalFeeForTokenRecovery = totalFeeForTokenRecovery.plus(rentExemptAmount);\n            }\n          }\n        } else {\n          throw Error('Not enough token funds to recover');\n        }\n      } else {\n        // there are no recoverable token accounts , need to check if there are tokens to recover\n        throw Error('Did not find token account to recover tokens, please check token account');\n      }\n    } else {\n      txBuilder = factory\n        .getTransferBuilder()\n        .nonce(blockhash)\n        .sender(bs58EncodedPublicKey)\n        .send({ address: params.recoveryDestination, amount: balance.toString() })\n        .feePayer(bs58EncodedPublicKey);\n    }\n\n    if (params.durableNonce) {\n      const durableNonceInfo = await this.getAccountInfo(params.durableNonce.publicKey, params.apiKey);\n      blockhash = durableNonceInfo.blockhash;\n      authority = durableNonceInfo.authority;\n\n      txBuilder.nonce(blockhash, {\n        walletNonceAddress: params.durableNonce.publicKey,\n        authWalletAddress: authority,\n      });\n    }\n\n    // build the transaction without fee\n    const unsignedTransactionWithoutFee = (await txBuilder.build()) as Transaction;\n    const serializedMessage = unsignedTransactionWithoutFee.solTransaction.serializeMessage().toString('base64');\n\n    const baseFee = await this.getFeeForMessage(serializedMessage, params.apiKey);\n    const feePerSignature = params.durableNonce ? baseFee / 2 : baseFee;\n    totalFee = totalFee.plus(new BigNumber(baseFee));\n    totalFeeForTokenRecovery = totalFeeForTokenRecovery.plus(new BigNumber(baseFee));\n    if (totalFee.gt(balance)) {\n      throw Error('Did not find address with funds to recover');\n    }\n\n    if (params.tokenContractAddress) {\n      // Check if there is sufficient native solana to recover tokens\n      if (new BigNumber(balance).lt(totalFeeForTokenRecovery)) {\n        throw Error(\n          'Not enough funds to pay for recover tokens fees, have: ' +\n            balance +\n            ' need: ' +\n            totalFeeForTokenRecovery.toString()\n        );\n      }\n      txBuilder.fee({ amount: feePerSignature });\n    } else {\n      const netAmount = new BigNumber(balance).minus(totalFee);\n      txBuilder = factory\n        .getTransferBuilder()\n        .nonce(blockhash)\n        .sender(bs58EncodedPublicKey)\n        .send({ address: params.recoveryDestination, amount: netAmount.toString() })\n        .feePayer(bs58EncodedPublicKey)\n        .fee({ amount: feePerSignature });\n\n      if (params.durableNonce) {\n        txBuilder.nonce(blockhash, {\n          walletNonceAddress: params.durableNonce.publicKey,\n          authWalletAddress: authority,\n        });\n      }\n    }\n\n    if (!isUnsignedSweep) {\n      // Sign the txn\n      if (!params.userKey) {\n        throw new Error('missing userKey');\n      }\n\n      if (!params.backupKey) {\n        throw new Error('missing backupKey');\n      }\n\n      if (!params.walletPassphrase) {\n        throw new Error('missing wallet passphrase');\n      }\n\n      // build the transaction with fee\n      const unsignedTransaction = (await txBuilder.build()) as Transaction;\n\n      const userKey = params.userKey.replace(/\\s/g, '');\n      const backupKey = params.backupKey.replace(/\\s/g, '');\n\n      if (!isMpcV2) {\n        // MPCv1 path: decrypt JSON signing material and use TSS signing\n        let userPrv: string;\n        try {\n          userPrv = await this.bitgo.decryptAsync({\n            input: userKey,\n            password: params.walletPassphrase,\n          });\n        } catch (e) {\n          throw new Error(`Error decrypting user keychain: ${e.message}`);\n        }\n        const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n        let backupPrv: string;\n        try {\n          backupPrv = await this.bitgo.decryptAsync({\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\n        const signatureHex = await EDDSAMethods.getTSSSignature(\n          userSigningMaterial,\n          backupSigningMaterial,\n          currPath,\n          unsignedTransaction\n        );\n        txBuilder.addSignature({ pub: bs58EncodedPublicKey } as PublicKey, signatureHex);\n      } else {\n        // MPCv2 path: decrypt CBOR reduced key shares and sign with MPS DSG protocol\n        const { userKeyShare, backupKeyShare, commonKeyChain } =\n          await EDDSAUtils.EddsaMPCv2RecoveryFunctions.getEddsaMpcV2RecoveryKeySharesFromReducedKey(\n            userKey,\n            backupKey,\n            params.walletPassphrase,\n            this.bitgo\n          );\n\n        if (commonKeyChain.toLowerCase() !== bitgoKey.toLowerCase()) {\n          throw new Error('EdDSA MPCv2 recovery: commonKeyChain from keycard does not match bitgoKey');\n        }\n\n        const signature = EDDSAUtils.EddsaMPCv2RecoveryFunctions.signRecoveryEddsaMPCv2(\n          unsignedTransaction.signablePayload,\n          currPath,\n          userKeyShare,\n          backupKeyShare,\n          commonKeyChain\n        );\n        txBuilder.addSignature({ pub: bs58EncodedPublicKey } as PublicKey, signature);\n      }\n    }\n\n    if (params.durableNonce) {\n      // add durable nonce account signature\n      txBuilder.sign({ key: params.durableNonce.secretKey });\n    }\n\n    const completedTransaction = await txBuilder.build();\n    const serializedTx = completedTransaction.toBroadcastFormat();\n    const derivationPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n    const inputs: OvcInput[] = [];\n    for (const input of completedTransaction.inputs) {\n      inputs.push({\n        address: input.address,\n        valueString: input.value,\n        value: new BigNumber(input.value).toNumber(),\n      });\n    }\n    const outputs: OvcOutput[] = [];\n    for (const output of completedTransaction.outputs) {\n      outputs.push({\n        address: output.address,\n        valueString: output.value,\n        coinName: output.coin ? output.coin : walletCoin,\n      });\n    }\n    const spendAmount = completedTransaction.inputs.length === 1 ? completedTransaction.inputs[0].value : 0;\n    const parsedTx = { inputs: inputs, outputs: outputs, spendAmount: spendAmount, type: '' };\n    const feeInfo = { fee: totalFeeForTokenRecovery.toNumber(), feeString: totalFee.toString() };\n    const coinSpecific = { commonKeychain: bitgoKey };\n    if (isUnsignedSweep) {\n      const transaction: MPCTx = {\n        serializedTx: serializedTx,\n        scanIndex: index,\n        coin: walletCoin,\n        signableHex: completedTransaction.signablePayload.toString('hex'),\n        derivationPath: derivationPath,\n        parsedTx: parsedTx,\n        feeInfo: feeInfo,\n        coinSpecific: coinSpecific,\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 = {\n      serializedTx: serializedTx,\n      scanIndex: index,\n    };\n    return transaction;\n  }\n\n  /**\n   * Builds a funds recovery transaction without BitGo\n   * @param {SolRecoveryOptions} params parameters needed to construct and\n   * (maybe) sign the transaction\n   *\n   * @returns {BaseBroadcastTransactionResult[]} the serialized transaction hex string and index\n   * of the address being swept\n   */\n  async recoverCloseATA(params: SolRecoveryOptions): Promise<BaseBroadcastTransactionResult[]> {\n    if (!params.bitgoKey) {\n      throw new Error('missing bitgoKey');\n    }\n\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    if (!params.closeAtaAddress || !this.isValidAddress(params.closeAtaAddress)) {\n      throw new Error('invalid closeAtaAddress');\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n\n    // Build the transaction\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    let balance = 0;\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 bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();\n\n    const accountBalance = await this.getAccountBalance(bs58EncodedPublicKey);\n\n    balance = await this.getAccountBalance(params.closeAtaAddress);\n    if (balance <= 0) {\n      throw Error('Did not find closeAtaAddress with sol funds to recover');\n    }\n\n    const factory = this.getBuilder();\n\n    let txBuilder;\n    let blockhash;\n    const recovertTxns: BaseBroadcastTransactionResult[] = [];\n\n    const rentExemptAmount = await this.getRentExemptAmount();\n\n    // do token recovery before closing ATA address\n    // check if any token is present on the closeAtaAddress\n    const tokenInfo = await this.getTokenAccountInfo(params.closeAtaAddress);\n    const tokenBalance = Number(tokenInfo.info.tokenAmount.amount);\n\n    if (tokenBalance > 0) {\n      // closeATA address has some token balance, it needs to be withdrawn before closing ATA\n      console.log(\n        `closeATA address ${params.closeAtaAddress} has token balance ${tokenBalance}, it needs to be withdrawn before closing ATA address`\n      );\n\n      if (!params.recoveryDestinationAtaAddress || !this.isValidAddress(params.recoveryDestinationAtaAddress)) {\n        throw new Error('invalid recoveryDestinationAtaAddress');\n      }\n\n      blockhash = await this.getBlockhash(params.apiKey);\n\n      txBuilder = factory\n        .getTokenTransferBuilder()\n        .nonce(blockhash)\n        .sender(bs58EncodedPublicKey)\n        .associatedTokenAccountRent(rentExemptAmount.toString())\n        .feePayer(bs58EncodedPublicKey);\n      const unsignedTransaction = (await txBuilder.build()) as Transaction;\n      const serializedMessage = unsignedTransaction.solTransaction.serializeMessage().toString('base64');\n      const feePerSignature = await this.getFeeForMessage(serializedMessage, params.apiKey);\n      const baseFee = params.durableNonce ? feePerSignature * 2 : feePerSignature;\n      const totalFee = new BigNumber(baseFee);\n      if (totalFee.gt(accountBalance)) {\n        throw Error('Did not find address with funds to recover');\n      }\n      txBuilder.fee({ amount: feePerSignature });\n\n      const network = this.getNetwork();\n      const token = getSolTokenFromAddress(tokenInfo.info.mint, network); // todo(WIN-5894) fix for ams\n      txBuilder.send({\n        address: params.recoveryDestinationAtaAddress,\n        amount: tokenBalance,\n        tokenName: token?.name,\n      });\n\n      const tokenRecoveryTxn = await this.signAndGenerateBroadcastableTransaction(\n        params,\n        txBuilder,\n        bs58EncodedPublicKey\n      );\n      const serializedTokenRecoveryTxn = (await tokenRecoveryTxn).serializedTx;\n      const broadcastTokenRecoveryTxn = await this.broadcastTransaction({\n        serializedSignedTransaction: serializedTokenRecoveryTxn,\n      });\n      logger.log(broadcastTokenRecoveryTxn);\n      recovertTxns.push(broadcastTokenRecoveryTxn);\n    }\n\n    // after recovering the token amount, attempting to close the ATA address\n    if (params.closeAtaAddress) {\n      blockhash = await this.getBlockhash(params.apiKey);\n\n      const ataCloseBuilder = () => {\n        const txBuilder = factory.getCloseAtaInitializationBuilder();\n        txBuilder.nonce(blockhash);\n        txBuilder.sender(bs58EncodedPublicKey);\n        txBuilder.accountAddress(params.closeAtaAddress ?? '');\n        txBuilder.destinationAddress(params.recoveryDestination);\n        txBuilder.authorityAddress(bs58EncodedPublicKey);\n        txBuilder.associatedTokenAccountRent(rentExemptAmount.toString());\n        return txBuilder;\n      };\n      txBuilder = ataCloseBuilder();\n    }\n    const closeATARecoveryTxn = await this.signAndGenerateBroadcastableTransaction(\n      params,\n      txBuilder,\n      bs58EncodedPublicKey\n    );\n    const serializedCloseATARecoveryTxn = (await closeATARecoveryTxn).serializedTx;\n    const broadcastCloseATARecoveryTxn = await this.broadcastTransaction({\n      serializedSignedTransaction: serializedCloseATARecoveryTxn,\n    });\n    logger.log(broadcastCloseATARecoveryTxn);\n    recovertTxns.push(broadcastCloseATARecoveryTxn);\n\n    return recovertTxns;\n  }\n\n  /**\n   * Recovers tokens from a nested ATA — an ATA whose owner is another ATA rather than a wallet address.\n   *\n   * This situation occurs when an external sender mistakenly calls createAssociatedTokenAccount with\n   * an ATA address as the owner instead of the root wallet address. The result is a \"nested ATA\"\n   * (ATA-2) owned by the wallet's normal ATA (ATA-1). Because ATA-1 is a PDA with no private key,\n   * the standard recoverCloseATA flow cannot sign for ATA-2.\n   *\n   * This method uses the Associated Token Account program's RecoverNested instruction, which allows\n   * the root wallet owner to sign and atomically move tokens from ATA-2 → ATA-1 and close ATA-2,\n   * returning the rent-exempt SOL to the wallet address.\n   *\n   * @param {SolRecoveryOptions} params - recovery params, requires nestedAtaAddress, ownerAtaAddress,\n   *   and tokenMintAddress in addition to the standard keychain fields\n   */\n  async recoverNestedAta(params: SolRecoveryOptions): Promise<BaseBroadcastTransactionResult> {\n    if (!params.bitgoKey) {\n      throw new Error('missing bitgoKey');\n    }\n\n    if (!params.recoveryDestination || !this.isValidAddress(params.recoveryDestination)) {\n      throw new Error('invalid recoveryDestination');\n    }\n\n    if (!params.nestedAtaAddress || !this.isValidAddress(params.nestedAtaAddress)) {\n      throw new Error('invalid nestedAtaAddress');\n    }\n\n    if (!params.ownerAtaAddress || !this.isValidAddress(params.ownerAtaAddress)) {\n      throw new Error('invalid ownerAtaAddress');\n    }\n\n    if (!params.tokenMintAddress || !this.isValidAddress(params.tokenMintAddress)) {\n      throw new Error('invalid tokenMintAddress');\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\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 bs58EncodedPublicKey = new SolKeyPair({ pub: accountId }).getAddress();\n\n    const blockhash = await this.getBlockhash(params.apiKey);\n    const rentExemptAmount = await this.getRentExemptAmount();\n\n    const factory = this.getBuilder();\n    const txBuilder = factory.getRecoverNestedAtaBuilder();\n    txBuilder.nonce(blockhash);\n    txBuilder.sender(bs58EncodedPublicKey);\n    txBuilder.feePayer(bs58EncodedPublicKey);\n    txBuilder.associatedTokenAccountRent(rentExemptAmount.toString());\n    txBuilder.nestedAccountAddress(params.nestedAtaAddress);\n    txBuilder.nestedMintAddress(params.tokenMintAddress);\n    txBuilder.destinationAccountAddress(params.ownerAtaAddress);\n    txBuilder.ownerAccountAddress(params.ownerAtaAddress);\n    txBuilder.ownerMintAddress(params.tokenMintAddress);\n    txBuilder.walletAddress(bs58EncodedPublicKey);\n\n    const recoverNestedTxn = await this.signAndGenerateBroadcastableTransaction(\n      params,\n      txBuilder,\n      bs58EncodedPublicKey\n    );\n\n    const serializedTxn = (await recoverNestedTxn).serializedTx;\n    const broadcastResult = await this.broadcastTransaction({\n      serializedSignedTransaction: serializedTxn,\n    });\n    logger.log(broadcastResult);\n\n    return broadcastResult;\n  }\n\n  async signAndGenerateBroadcastableTransaction(\n    params: SolRecoveryOptions,\n    txBuilder: any,\n    bs58EncodedPublicKey: string\n  ): Promise<MPCTx> {\n    // Sign the txn\n    if (!params.userKey) {\n      throw new Error('missing userKey');\n    }\n\n    if (!params.backupKey) {\n      throw new Error('missing backupKey');\n    }\n\n    if (!params.walletPassphrase) {\n      throw new Error('missing wallet passphrase');\n    }\n\n    const unsignedTransaction = (await txBuilder.build()) as Transaction;\n\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\n    try {\n      userPrv = await this.bitgo.decryptAsync({\n        input: userKey,\n        password: params.walletPassphrase,\n      });\n    } catch (e) {\n      throw new Error(`Error decrypting user keychain: ${e.message}`);\n    }\n\n    const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n    let backupPrv;\n    try {\n      backupPrv = await this.bitgo.decryptAsync({\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\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n\n    const signatureHex = await EDDSAMethods.getTSSSignature(\n      userSigningMaterial,\n      backupSigningMaterial,\n      currPath,\n      unsignedTransaction\n    );\n\n    const publicKeyObj = { pub: bs58EncodedPublicKey };\n    txBuilder.addSignature(publicKeyObj as PublicKey, signatureHex);\n\n    const completedTransaction = await txBuilder.build();\n    const serializedTx = completedTransaction.toBroadcastFormat();\n    const transaction: MPCTx = {\n      serializedTx: serializedTx,\n      scanIndex: index,\n    };\n    return transaction;\n  }\n\n  /**\n   * Builds native SOL 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 {SolConsolidationRecoveryOptions} 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: SolConsolidationRecoveryOptions): Promise<MPCTxs | MPCSweepTxs> {\n    const isUnsignedSweep = !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    // validate durable nonces array\n    if (!params.durableNonces) {\n      throw new Error('Missing durable nonces');\n    }\n    if (!params.durableNonces.publicKeys) {\n      throw new Error('Invalid durable nonces: missing public keys');\n    }\n    if (!params.durableNonces.secretKey) {\n      throw new Error('Invalid durable nonces array: missing secret key');\n    }\n\n    const bitgoKey = params.bitgoKey.replace(/\\s/g, '');\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    const baseAddressIndex = 0;\n    const baseAddressPath = params.seed\n      ? getDerivationPath(params.seed) + `/${baseAddressIndex}`\n      : `m/${baseAddressIndex}`;\n    const accountId = MPC.deriveUnhardened(bitgoKey, baseAddressPath).slice(0, 64);\n    const baseAddress = new SolKeyPair({ pub: accountId }).getAddress();\n\n    let durableNoncePubKeysIndex = 0;\n    const durableNoncePubKeysLength = params.durableNonces.publicKeys.length;\n    const consolidationTransactions: any[] = [];\n    let lastScanIndex = startIdx;\n\n    for (let i = startIdx; i < endIdx; i++) {\n      const recoverParams = {\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        durableNonce: {\n          publicKey: params.durableNonces.publicKeys[durableNoncePubKeysIndex],\n          secretKey: params.durableNonces.secretKey,\n        },\n        tokenContractAddress: params.tokenContractAddress,\n        apiKey: params.apiKey,\n        programId: params.programId,\n      };\n\n      let recoveryTransaction;\n      try {\n        recoveryTransaction = await this.recover(recoverParams);\n      } catch (e) {\n        if (\n          e.message === 'Did not find address with funds to recover' ||\n          e.message === 'Did not find token account to recover tokens, please check token account' ||\n          e.message === 'Not enough token funds to recover'\n        ) {\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\n      lastScanIndex = i;\n      durableNoncePubKeysIndex++;\n      if (durableNoncePubKeysIndex >= durableNoncePubKeysLength) {\n        // no more available nonce accounts to create transactions\n        break;\n      }\n    }\n\n    if (consolidationTransactions.length === 0) {\n      throw new Error('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        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  getTokenEnablementConfig(): TokenEnablementConfig {\n    return {\n      requiresTokenEnablement: true,\n      supportsMultipleTokenEnablements: true,\n    };\n  }\n\n  private getBuilder(): TransactionBuilderFactory {\n    return new TransactionBuilderFactory(coins.get(this.getChain()));\n  }\n\n  async broadcastTransaction({\n    serializedSignedTransaction,\n  }: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {\n    validateRawTransaction(serializedSignedTransaction, true, true);\n    const response = await this.getDataFromNode({\n      payload: {\n        id: '1',\n        jsonrpc: '2.0',\n        method: 'sendTransaction',\n        params: [\n          serializedSignedTransaction,\n          {\n            encoding: 'base64',\n          },\n        ],\n      },\n    });\n\n    if (response.body.error) {\n      throw new Error('Error broadcasting transaction: ' + response.body.error.message);\n    }\n\n    return { txId: response.body.result };\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  /** @inheritDoc */\n  setCoinSpecificFieldsInIntent(intent: PopulatedIntent, params: PrebuildTransactionWithIntentOptions): void {\n    // Handle custom instructions for Solana\n    if (params.solInstructions) {\n      intent.solInstructions = params.solInstructions;\n    }\n\n    // Handle versioned transaction data for Solana\n    if (params.solVersionedTransactionData) {\n      intent.solVersionedTransactionData = params.solVersionedTransactionData;\n    }\n  }\n}\n"]}