@bitgo-beta/sdk-coin-sol 7.6.4-beta.72 → 7.6.4-beta.721

package/dist/esm/sol.js

@@ -0,0 +1,1632 @@
+/**
+ * @prettier
+ */
+import { TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { PublicKey as SolPublicKey } from '@solana/web3.js';
+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 nacl from 'tweetnacl';
+import assert from 'assert';
+import { BaseCoin, EDDSAMethods, Environments, MAX_SOL_MESSAGE_BYTES, MessageStandardType, multisigTypes, TransactionType, validateSiwsMessage, verifyEddsaTssWalletAddress, deriveMPCWalletAddress, UnexpectedAddressError, getEddsaSigningMaterial, signEddsaMpcV2RecoveryTx, } from '@bitgo-beta/sdk-core';
+import { auditEddsaPrivateKey, 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 { buildSolAccountConnection, resolvePermissionlessThaw as resolvePermissionlessThawLib, resolveTransferHookAccounts as resolveTransferHookAccountsLib, } from './lib/token2022Resolve';
+import { getAssociatedTokenAccountAddress, getSolTokenFromAddress, getSolTokenFromTokenName, isValidAddress, isValidPrivateKey, isValidPublicKey, validateRawTransaction, } from './lib/utils';
+import { validateRawTransactionV1 } from './lib/serialization/parseWireTransaction';
+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;
+    }
+    /** @inheritDoc */
+    validateSignableMessage(message) {
+        if (message.messageStandardType !== MessageStandardType.SIMPLE) {
+            throw new Error(`SOL message signing supports only the ${MessageStandardType.SIMPLE} standard, got ${message.messageStandardType}`);
+        }
+        if (!message.signerAddress) {
+            throw new Error('signerAddress is required to sign a SOL message');
+        }
+        if (!message.messageRaw) {
+            throw new Error('messageRaw is required to sign a SOL message');
+        }
+        const messageBytes = Buffer.byteLength(message.messageRaw);
+        if (messageBytes > MAX_SOL_MESSAGE_BYTES) {
+            throw new Error(`SOL message exceeds maximum size: ${messageBytes} > ${MAX_SOL_MESSAGE_BYTES} bytes`);
+        }
+        // The signing stack (BGM_SOL_MESSAGE) signs only well-formed SIWS messages; reject
+        // non-SIWS here so failures surface client-side instead of mid-ceremony.
+        validateSiwsMessage(message.messageRaw);
+    }
+    /** 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);
+        // Allow unsupported tokens (not in static map) to use their mint address as tokenName during parsing
+        transaction.setUseTokenAddressTokenName(true);
+        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', 'tokenAddress', 'programId']));
+            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 tokenFromMap = getSolTokenFromTokenName(recipientFromUser.tokenName);
+                        const mintAddress = tokenFromMap?.tokenAddress ?? recipientFromUser.tokenAddress;
+                        const programId = tokenFromMap?.programId ?? recipientFromUser.programId;
+                        if (!mintAddress) {
+                            return false;
+                        }
+                        return getAssociatedTokenAccountAddress(mintAddress, recipientFromUser.address, true, 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 tokenFromMap = getSolTokenFromTokenName(output.tokenName);
+                        if (tokenFromMap?.tokenAddress && tokenFromMap?.programId) {
+                            ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(tokenFromMap.tokenAddress, walletRootAddress, true, tokenFromMap.programId);
+                        }
+                        else {
+                            // For unsupported tokens, explainTransaction sets tokenName to the mint address itself.
+                            // Attempt ATA derivation using tokenName as the mint address; programId defaults to TOKEN_PROGRAM_ID.
+                            ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(output.tokenName, walletRootAddress, true);
+                        }
+                    }
+                    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 &&
+            !isCloseAssociatedTokenAccountTx) {
+            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) {
+        // Derive the native owner (wallet) address from the commonKeychain.
+        const { address: ownerAddress, 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));
+        // No token requested: return the native SOL receive address.
+        if (!params.tokenName) {
+            return { address: ownerAddress, index: params.index, derivationPath };
+        }
+        // Token requested: the deposit address is the owner's Associated Token Account (ATA) for the
+        // token's mint, derived the same way SOL token addresses are produced elsewhere in this coin.
+        const token = getSolTokenFromTokenName(params.tokenName);
+        if (!token || token.tokenAddress === undefined || token.programId === undefined) {
+            throw new Error(`unknown or unsupported SOL token: ${params.tokenName}`);
+        }
+        const address = await getAssociatedTokenAccountAddress(token.tokenAddress, ownerAddress, true, token.programId);
+        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 });
+        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,
+        };
+    }
+    /**
+     * Build a minimal `Connection`-like shim backed by {@link getDataFromNode}.
+     *
+     * `@solana/spl-token`'s transfer-hook resolution helpers only require
+     * `getAccountInfo(publicKey)` returning an `AccountInfo<Buffer>`. Rather than
+     * open a second RPC transport, we reuse the existing public-node request path
+     * as the {@link SolAccountFetcher} (base64-decoding the JSON-RPC response here),
+     * then adapt it via {@link buildSolAccountConnection}.
+     *
+     * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL
+     * @returns {Connection} a shim exposing `getAccountInfo`, cast to `Connection`
+     */
+    buildTransferHookConnection(apiKey) {
+        const fetch = async (address) => {
+            const response = await this.getDataFromNode({
+                payload: {
+                    id: '1',
+                    jsonrpc: '2.0',
+                    method: 'getAccountInfo',
+                    params: [address, { encoding: 'base64' }],
+                },
+            }, apiKey);
+            if (response.status !== 200) {
+                throw new Error('Account not found');
+            }
+            const value = response.body?.result?.value;
+            if (!value) {
+                return null;
+            }
+            const [data] = value.data;
+            return {
+                executable: value.executable,
+                owner: new SolPublicKey(value.owner),
+                lamports: value.lamports,
+                data: Buffer.from(data, 'base64'),
+                rentEpoch: value.rentEpoch,
+            };
+        };
+        return buildSolAccountConnection(fetch);
+    }
+    /**
+     * Resolve the Token-2022 Transfer Hook extra accounts for a specific transfer.
+     *
+     * Thin wrapper around {@link resolveTransferHookAccountsLib}: builds a connection
+     * over this coin's node transport and delegates the resolution. See the standalone
+     * function in `./lib/token2022Resolve` for the full behavior.
+     *
+     * Builders remain offline, so the caller (e.g. wallet-platform) is responsible
+     * for invoking this and threading the result into the token-transfer builder via
+     * `transferHookAccounts(...)`. When the mint has no Transfer Hook, this returns
+     * an empty array and callers can omit the param.
+     *
+     * @param {string} mint - the Token-2022 mint address
+     * @param {string} source - the source token account (sender ATA)
+     * @param {string} destination - the destination token account (recipient ATA)
+     * @param {string} owner - the source account owner / transfer authority
+     * @param {string} amount - the raw transfer amount in base units
+     * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL
+     * @returns {Promise<ExtraAccountMeta[]>} ordered extra account metas, or [] when no hook
+     */
+    async resolveTransferHookAccounts(mint, source, destination, owner, amount, apiKey) {
+        const connection = this.buildTransferHookConnection(apiKey);
+        return resolveTransferHookAccountsLib(connection, { mint, source, destination, owner, amount });
+    }
+    /**
+     * Resolve the sRFC-37 Token ACL permissionless-thaw dependencies for a token account.
+     *
+     * Thin wrapper around {@link resolvePermissionlessThawLib}: builds a connection
+     * over this coin's node transport and delegates the resolution. See the standalone
+     * function in `./lib/token2022Resolve` for the full behavior.
+     *
+     * Builders remain offline, so the caller (e.g. wallet-platform) invokes this and threads the
+     * result into the token-transfer builder via `permissionlessThaw(...)`, which bundles the thaw
+     * atomically with any ATA creation and the transfer. When the mint is not a Token ACL mint, or
+     * permissionless thaw is disabled, this returns `{ applicable: false }` and callers skip the thaw.
+     *
+     * @param {string} mint - the Token-2022 mint address
+     * @param {string} tokenAccount - the token account (ATA) to thaw
+     * @param {string} tokenAccountOwner - the owner of the token account
+     * @param {string} authority - the signer invoking the thaw (fee payer / authority)
+     * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL
+     * @returns {Promise<ResolvePermissionlessThawResult>} the resolved thaw params, or `{ applicable: false }`
+     */
+    async resolvePermissionlessThaw(mint, tokenAccount, tokenAccountOwner, authority, apiKey) {
+        const connection = this.buildTransferHookConnection(apiKey);
+        return resolvePermissionlessThawLib(connection, { mint, tokenAccount, tokenAccountOwner, authority });
+    }
+    /** 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;
+            const ovc = req[i].ovc?.[0];
+            const mpcv2SignatureHex = ovc?.eddsaMpcv2Signature;
+            if (!ovc || (!mpcv2SignatureHex && !ovc.eddsaSignature)) {
+                throw new Error('Missing signature(s)');
+            }
+            if (!transaction.signableHex) {
+                throw new Error('Missing signable hex');
+            }
+            const messageBuffer = Buffer.from(transaction.signableHex, 'hex');
+            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();
+            let signatureHex;
+            if (mpcv2SignatureHex) {
+                // MPCv2 (OVC 5-pass): raw 64-byte Ed25519 signature. Verify against the
+                // same derived public key the transaction is signed under, then embed as-is.
+                const signature = Buffer.from(mpcv2SignatureHex, 'hex');
+                const isValid = nacl.sign.detached.verify(messageBuffer, signature, Buffer.from(accountId, 'hex'));
+                if (!isValid) {
+                    throw new Error('Invalid signature');
+                }
+                signatureHex = signature;
+            }
+            else {
+                const result = MPC.verify(messageBuffer, ovc.eddsaSignature);
+                if (!result) {
+                    throw new Error('Invalid signature');
+                }
+                signatureHex = Buffer.concat([
+                    Buffer.from(ovc.eddsaSignature.R, 'hex'),
+                    Buffer.from(ovc.eddsaSignature.sigma, 'hex'),
+                ]);
+            }
+            // 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.
+        // When multisigTypeVersion is pre-resolved by the caller (e.g. recoverConsolidations),
+        // skip keycard decryption to avoid redundant work on each loop iteration.
+        const isMpcV2 = params.multisigTypeVersion === 'MPCv2'
+            ? true
+            : await this.isMpcv2SigningMaterial(params.userKey, params.backupKey, params.walletPassphrase);
+        let balance = 0;
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const MPC = await EDDSAMethods.getInitializedMpcInstance();
+        const 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());
+            await this.addRecoverySignature(params, txBuilder, bs58EncodedPublicKey, isMpcV2, unsignedTransaction, currPath, bitgoKey);
+        }
+        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, '');
+        // Validate signing keys and detect MPCv2 format early
+        const isMpcV2 = await this.isMpcv2SigningMaterial(params.userKey, params.backupKey, params.walletPassphrase);
+        // Build the transaction
+        let balance = 0;
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const MPC = await EDDSAMethods.getInitializedMpcInstance();
+        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, isMpcV2);
+            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, isMpcV2);
+        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 userKey = params.userKey?.replace(/\s/g, '') ?? '';
+        const isMpcV2 = params.walletPassphrase
+            ? (await getEddsaSigningMaterial(userKey, params.walletPassphrase, this.bitgo)).version === 'v2'
+            : false;
+        const index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        const accountId = (await EDDSAMethods.getInitializedMpcInstance())
+            .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, isMpcV2);
+        const serializedTxn = (await recoverNestedTxn).serializedTx;
+        const broadcastResult = await this.broadcastTransaction({
+            serializedSignedTransaction: serializedTxn,
+        });
+        logger.log(broadcastResult);
+        return broadcastResult;
+    }
+    async signAndGenerateBroadcastableTransaction(params, txBuilder, bs58EncodedPublicKey, isMpcV2 = false) {
+        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 index = params.index || 0;
+        const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;
+        await this.addRecoverySignature(params, txBuilder, bs58EncodedPublicKey, isMpcV2, unsignedTransaction, currPath, params.bitgoKey.replace(/\s/g, ''));
+        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) {
+        if (!params.bitgoKey) {
+            throw new Error('missing bitgoKey');
+        }
+        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 userKey = params.userKey?.replace(/\s/g, '') ?? '';
+        // Detect once at the top to avoid decrypting the keycard on every iteration of the scan loop.
+        // For unsigned sweep (no passphrase), isMpcV2 is false — cold MPCv2 is out of scope.
+        const isMpcV2 = params.walletPassphrase
+            ? (await getEddsaSigningMaterial(userKey, params.walletPassphrase, this.bitgo)).version === 'v2'
+            : false;
+        const baseAddressIndex = 0;
+        const baseAddressPath = params.seed
+            ? getDerivationPath(params.seed) + `/${baseAddressIndex}`
+            : `m/${baseAddressIndex}`;
+        const baseAccountId = (await EDDSAMethods.getInitializedMpcInstance())
+            .deriveUnhardened(bitgoKey, baseAddressPath)
+            .slice(0, 64);
+        const baseAddress = new SolKeyPair({ pub: baseAccountId }).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,
+                multisigTypeVersion: isMpcV2 ? 'MPCv2' : undefined,
+                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 addRecoverySignature(params, txBuilder, bs58EncodedPublicKey, isMpcV2, unsignedTransaction, currPath, bitgoKey) {
+        assert(params.userKey, 'missing userKey');
+        assert(params.backupKey, 'missing backupKey');
+        const userKey = params.userKey.replace(/\s/g, '');
+        const backupKey = params.backupKey.replace(/\s/g, '');
+        if (!isMpcV2) {
+            let userPrv;
+            try {
+                userPrv = await this.bitgo.decrypt({
+                    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.decrypt({
+                    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 {
+            const signature = await signEddsaMpcV2RecoveryTx({
+                message: unsignedTransaction.signablePayload,
+                userKey,
+                backupKey,
+                walletPassphrase: params.walletPassphrase,
+                bitgoKey,
+                derivationPath: currPath,
+                bitgo: this.bitgo,
+            });
+            txBuilder.addSignature({ pub: bs58EncodedPublicKey }, signature);
+        }
+    }
+    async isMpcv2SigningMaterial(userKey, backupKey, walletPassphrase) {
+        if (!walletPassphrase)
+            return false;
+        if (!userKey)
+            throw new Error('missing userKey');
+        if (!backupKey)
+            throw new Error('missing backupKey');
+        const material = await getEddsaSigningMaterial(userKey.replace(/\s/g, ''), walletPassphrase, this.bitgo);
+        return material.version === 'v2';
+    }
+    async broadcastTransaction({ serializedSignedTransaction, }) {
+        let rawBytes;
+        let isV1 = false;
+        try {
+            rawBytes = Buffer.from(serializedSignedTransaction, 'base64');
+            // v1 (SIMD-0296/0385) transactions start with the 0x81 version prefix.
+            isV1 = rawBytes.length > 0 && rawBytes[0] === 0x81;
+        }
+        catch {
+            // Malformed or non-string input: not a v1 transaction. Fall through to the
+            // legacy validateRawTransaction path, which raises a descriptive error.
+        }
+        if (isV1) {
+            // Structural + signature validation parity with the legacy path (which uses
+            // validateRawTransaction(raw, true, true)). The 4096-byte v1 size limit is
+            // enforced inside validateRawTransactionV1 (parseWireTransaction).
+            validateRawTransactionV1(rawBytes);
+        }
+        else {
+            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 { AccountInfo, Connection, PublicKey as SolPublicKey } from '@solana/web3.js';\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';\nimport nacl from 'tweetnacl';\nimport assert from 'assert';\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  MAX_SOL_MESSAGE_BYTES,\n  Memo,\n  Message,\n  MessageStandardType,\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  validateSiwsMessage,\n  verifyEddsaTssWalletAddress,\n  deriveMPCWalletAddress,\n  DeriveAddressOptions,\n  DeriveAddressResult,\n  UnexpectedAddressError,\n  getEddsaSigningMaterial,\n  signEddsaMpcV2RecoveryTx,\n} from '@bitgo-beta/sdk-core';\nimport { auditEddsaPrivateKey, 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 {\n  AtaClose,\n  AtaRecoverNested,\n  ExtraAccountMeta,\n  TransactionExplanation as SolLibTransactionExplanation,\n} from './lib/iface';\nimport { InstructionBuilderTypes } from './lib/constants';\nimport {\n  ResolvePermissionlessThawResult,\n  SolAccountFetcher,\n  buildSolAccountConnection,\n  resolvePermissionlessThaw as resolvePermissionlessThawLib,\n  resolveTransferHookAccounts as resolveTransferHookAccountsLib,\n} from './lib/token2022Resolve';\nimport {\n  getAssociatedTokenAccountAddress,\n  getSolTokenFromAddress,\n  getSolTokenFromTokenName,\n  isValidAddress,\n  isValidPrivateKey,\n  isValidPublicKey,\n  validateRawTransaction,\n} from './lib/utils';\nimport { validateRawTransactionV1 } from './lib/serialization/parseWireTransaction';\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\n// `ResolvePermissionlessThawResult` now lives in `./lib/token2022Resolve`; re-exported here to\n// preserve the existing `@bitgo-beta/sdk-coin-sol` public export surface.\nexport type { ResolvePermissionlessThawResult };\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  // Pre-resolved signing route; when set, skips per-call keycard decryption in recover().\n  multisigTypeVersion?: 'MPCv2';\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  /** @inheritDoc */\n  validateSignableMessage(message: Pick<Message, 'messageRaw' | 'messageStandardType' | 'signerAddress'>): void {\n    if (message.messageStandardType !== MessageStandardType.SIMPLE) {\n      throw new Error(\n        `SOL message signing supports only the ${MessageStandardType.SIMPLE} standard, got ${message.messageStandardType}`\n      );\n    }\n    if (!message.signerAddress) {\n      throw new Error('signerAddress is required to sign a SOL message');\n    }\n    if (!message.messageRaw) {\n      throw new Error('messageRaw is required to sign a SOL message');\n    }\n    const messageBytes = Buffer.byteLength(message.messageRaw);\n    if (messageBytes > MAX_SOL_MESSAGE_BYTES) {\n      throw new Error(`SOL message exceeds maximum size: ${messageBytes} > ${MAX_SOL_MESSAGE_BYTES} bytes`);\n    }\n    // The signing stack (BGM_SOL_MESSAGE) signs only well-formed SIWS messages; reject\n    // non-SIWS here so failures surface client-side instead of mid-ceremony.\n    validateSiwsMessage(message.messageRaw);\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    // Allow unsupported tokens (not in static map) to use their mint address as tokenName during parsing\n    transaction.setUseTokenAddressTokenName(true);\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', 'tokenAddress', 'programId'])\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 tokenFromMap = getSolTokenFromTokenName(recipientFromUser.tokenName);\n              const mintAddress = tokenFromMap?.tokenAddress ?? recipientFromUser.tokenAddress;\n              const programId = tokenFromMap?.programId ?? recipientFromUser.programId;\n\n              if (!mintAddress) {\n                return false;\n              }\n\n              return getAssociatedTokenAccountAddress(mintAddress, recipientFromUser.address, true, programId).then(\n                (ata: string) => {\n                  return ata === recipientFromTx.address;\n                }\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 tokenFromMap = getSolTokenFromTokenName(output.tokenName);\n            if (tokenFromMap?.tokenAddress && tokenFromMap?.programId) {\n              ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(\n                tokenFromMap.tokenAddress,\n                walletRootAddress as string,\n                true,\n                tokenFromMap.programId\n              );\n            } else {\n              // For unsupported tokens, explainTransaction sets tokenName to the mint address itself.\n              // Attempt ATA derivation using tokenName as the mint address; programId defaults to TOKEN_PROGRAM_ID.\n              ataAddressCache[output.tokenName] = await getAssociatedTokenAccountAddress(\n                output.tokenName,\n                walletRootAddress as string,\n                true\n              );\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 (\n      consolidateId === undefined &&\n      transactionJson.feePayer !== walletRootAddress &&\n      !isCloseAssociatedTokenAccountTx\n    ) {\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    // Derive the native owner (wallet) address from the commonKeychain.\n    const { address: ownerAddress, 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    // No token requested: return the native SOL receive address.\n    if (!params.tokenName) {\n      return { address: ownerAddress, index: params.index, derivationPath };\n    }\n\n    // Token requested: the deposit address is the owner's Associated Token Account (ATA) for the\n    // token's mint, derived the same way SOL token addresses are produced elsewhere in this coin.\n    const token = getSolTokenFromTokenName(params.tokenName);\n    if (!token || token.tokenAddress === undefined || token.programId === undefined) {\n      throw new Error(`unknown or unsupported SOL token: ${params.tokenName}`);\n    }\n    const address = await getAssociatedTokenAccountAddress(token.tokenAddress, ownerAddress, true, token.programId);\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    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  /**\n   * Build a minimal `Connection`-like shim backed by {@link getDataFromNode}.\n   *\n   * `@solana/spl-token`'s transfer-hook resolution helpers only require\n   * `getAccountInfo(publicKey)` returning an `AccountInfo<Buffer>`. Rather than\n   * open a second RPC transport, we reuse the existing public-node request path\n   * as the {@link SolAccountFetcher} (base64-decoding the JSON-RPC response here),\n   * then adapt it via {@link buildSolAccountConnection}.\n   *\n   * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL\n   * @returns {Connection} a shim exposing `getAccountInfo`, cast to `Connection`\n   */\n  protected buildTransferHookConnection(apiKey?: string): Connection {\n    const fetch: SolAccountFetcher = async (address: string): Promise<AccountInfo<Buffer> | null> => {\n      const response = await this.getDataFromNode(\n        {\n          payload: {\n            id: '1',\n            jsonrpc: '2.0',\n            method: 'getAccountInfo',\n            params: [address, { encoding: 'base64' }],\n          },\n        },\n        apiKey\n      );\n      if (response.status !== 200) {\n        throw new Error('Account not found');\n      }\n      const value = response.body?.result?.value;\n      if (!value) {\n        return null;\n      }\n      const [data] = value.data as [string, string];\n      return {\n        executable: value.executable,\n        owner: new SolPublicKey(value.owner),\n        lamports: value.lamports,\n        data: Buffer.from(data, 'base64'),\n        rentEpoch: value.rentEpoch,\n      };\n    };\n    return buildSolAccountConnection(fetch);\n  }\n\n  /**\n   * Resolve the Token-2022 Transfer Hook extra accounts for a specific transfer.\n   *\n   * Thin wrapper around {@link resolveTransferHookAccountsLib}: builds a connection\n   * over this coin's node transport and delegates the resolution. See the standalone\n   * function in `./lib/token2022Resolve` for the full behavior.\n   *\n   * Builders remain offline, so the caller (e.g. wallet-platform) is responsible\n   * for invoking this and threading the result into the token-transfer builder via\n   * `transferHookAccounts(...)`. When the mint has no Transfer Hook, this returns\n   * an empty array and callers can omit the param.\n   *\n   * @param {string} mint - the Token-2022 mint address\n   * @param {string} source - the source token account (sender ATA)\n   * @param {string} destination - the destination token account (recipient ATA)\n   * @param {string} owner - the source account owner / transfer authority\n   * @param {string} amount - the raw transfer amount in base units\n   * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL\n   * @returns {Promise<ExtraAccountMeta[]>} ordered extra account metas, or [] when no hook\n   */\n  async resolveTransferHookAccounts(\n    mint: string,\n    source: string,\n    destination: string,\n    owner: string,\n    amount: string,\n    apiKey?: string\n  ): Promise<ExtraAccountMeta[]> {\n    const connection = this.buildTransferHookConnection(apiKey);\n    return resolveTransferHookAccountsLib(connection, { mint, source, destination, owner, amount });\n  }\n\n  /**\n   * Resolve the sRFC-37 Token ACL permissionless-thaw dependencies for a token account.\n   *\n   * Thin wrapper around {@link resolvePermissionlessThawLib}: builds a connection\n   * over this coin's node transport and delegates the resolution. See the standalone\n   * function in `./lib/token2022Resolve` for the full behavior.\n   *\n   * Builders remain offline, so the caller (e.g. wallet-platform) invokes this and threads the\n   * result into the token-transfer builder via `permissionlessThaw(...)`, which bundles the thaw\n   * atomically with any ATA creation and the transfer. When the mint is not a Token ACL mint, or\n   * permissionless thaw is disabled, this returns `{ applicable: false }` and callers skip the thaw.\n   *\n   * @param {string} mint - the Token-2022 mint address\n   * @param {string} tokenAccount - the token account (ATA) to thaw\n   * @param {string} tokenAccountOwner - the owner of the token account\n   * @param {string} authority - the signer invoking the thaw (fee payer / authority)\n   * @param {string} [apiKey] - optional Alchemy API key threaded to the node URL\n   * @returns {Promise<ResolvePermissionlessThawResult>} the resolved thaw params, or `{ applicable: false }`\n   */\n  async resolvePermissionlessThaw(\n    mint: string,\n    tokenAccount: string,\n    tokenAccountOwner: string,\n    authority: string,\n    apiKey?: string\n  ): Promise<ResolvePermissionlessThawResult> {\n    const connection = this.buildTransferHookConnection(apiKey);\n    return resolvePermissionlessThawLib(connection, { mint, tokenAccount, tokenAccountOwner, authority });\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      const ovc = req[i].ovc?.[0];\n      const mpcv2SignatureHex = ovc?.eddsaMpcv2Signature;\n      if (!ovc || (!mpcv2SignatureHex && !ovc.eddsaSignature)) {\n        throw new Error('Missing signature(s)');\n      }\n      if (!transaction.signableHex) {\n        throw new Error('Missing signable hex');\n      }\n      const messageBuffer = Buffer.from(transaction.signableHex!, 'hex');\n      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      let signatureHex: Buffer;\n      if (mpcv2SignatureHex) {\n        // MPCv2 (OVC 5-pass): raw 64-byte Ed25519 signature. Verify against the\n        // same derived public key the transaction is signed under, then embed as-is.\n        const signature = Buffer.from(mpcv2SignatureHex, 'hex');\n        const isValid = nacl.sign.detached.verify(messageBuffer, signature, Buffer.from(accountId, 'hex'));\n        if (!isValid) {\n          throw new Error('Invalid signature');\n        }\n        signatureHex = signature;\n      } else {\n        const result = MPC.verify(messageBuffer, ovc.eddsaSignature);\n        if (!result) {\n          throw new Error('Invalid signature');\n        }\n        signatureHex = Buffer.concat([\n          Buffer.from(ovc.eddsaSignature.R, 'hex'),\n          Buffer.from(ovc.eddsaSignature.sigma, 'hex'),\n        ]);\n      }\n\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    // When multisigTypeVersion is pre-resolved by the caller (e.g. recoverConsolidations),\n    // skip keycard decryption to avoid redundant work on each loop iteration.\n    const isMpcV2 =\n      params.multisigTypeVersion === 'MPCv2'\n        ? true\n        : await this.isMpcv2SigningMaterial(params.userKey, params.backupKey, params.walletPassphrase);\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    const MPC = await EDDSAMethods.getInitializedMpcInstance();\n    const accountId = MPC.deriveUnhardened(bitgoKey, currPath).slice(0, 64);\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      await this.addRecoverySignature(\n        params,\n        txBuilder,\n        bs58EncodedPublicKey,\n        isMpcV2,\n        unsignedTransaction,\n        currPath,\n        bitgoKey\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    // Validate signing keys and detect MPCv2 format early\n    const isMpcV2 = await this.isMpcv2SigningMaterial(params.userKey, params.backupKey, params.walletPassphrase);\n\n    // Build the transaction\n    let balance = 0;\n\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n\n    const MPC = await EDDSAMethods.getInitializedMpcInstance();\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        isMpcV2\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      isMpcV2\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 userKey = params.userKey?.replace(/\\s/g, '') ?? '';\n\n    const isMpcV2 = params.walletPassphrase\n      ? (await getEddsaSigningMaterial(userKey, params.walletPassphrase, this.bitgo)).version === 'v2'\n      : false;\n\n    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n    const accountId = (await EDDSAMethods.getInitializedMpcInstance())\n      .deriveUnhardened(bitgoKey, currPath)\n      .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      isMpcV2\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: TransactionBuilder,\n    bs58EncodedPublicKey: string,\n    isMpcV2 = false\n  ): Promise<MPCTx> {\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    const index = params.index || 0;\n    const currPath = params.seed ? getDerivationPath(params.seed) + `/${index}` : `m/${index}`;\n\n    await this.addRecoverySignature(\n      params,\n      txBuilder,\n      bs58EncodedPublicKey,\n      isMpcV2,\n      unsignedTransaction,\n      currPath,\n      params.bitgoKey.replace(/\\s/g, '')\n    );\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    if (!params.bitgoKey) {\n      throw new Error('missing bitgoKey');\n    }\n\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 userKey = params.userKey?.replace(/\\s/g, '') ?? '';\n\n    // Detect once at the top to avoid decrypting the keycard on every iteration of the scan loop.\n    // For unsigned sweep (no passphrase), isMpcV2 is false — cold MPCv2 is out of scope.\n    const isMpcV2 = params.walletPassphrase\n      ? (await getEddsaSigningMaterial(userKey, params.walletPassphrase, this.bitgo)).version === 'v2'\n      : false;\n\n    const baseAddressIndex = 0;\n    const baseAddressPath = params.seed\n      ? getDerivationPath(params.seed) + `/${baseAddressIndex}`\n      : `m/${baseAddressIndex}`;\n    const baseAccountId = (await EDDSAMethods.getInitializedMpcInstance())\n      .deriveUnhardened(bitgoKey, baseAddressPath)\n      .slice(0, 64);\n    const baseAddress = new SolKeyPair({ pub: baseAccountId }).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        multisigTypeVersion: isMpcV2 ? ('MPCv2' as const) : undefined,\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  private async addRecoverySignature(\n    params: SolRecoveryOptions,\n    txBuilder: TransactionBuilder,\n    bs58EncodedPublicKey: string,\n    isMpcV2: boolean,\n    unsignedTransaction: Transaction,\n    currPath: string,\n    bitgoKey: string\n  ): Promise<void> {\n    assert(params.userKey, 'missing userKey');\n    assert(params.backupKey, 'missing backupKey');\n    const userKey = params.userKey.replace(/\\s/g, '');\n    const backupKey = params.backupKey.replace(/\\s/g, '');\n\n    if (!isMpcV2) {\n      let userPrv: string;\n      try {\n        userPrv = await this.bitgo.decrypt({\n          input: userKey,\n          password: params.walletPassphrase!,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting user keychain: ${e.message}`);\n      }\n      const userSigningMaterial = JSON.parse(userPrv) as EDDSAMethodTypes.UserSigningMaterial;\n\n      let backupPrv: string;\n      try {\n        backupPrv = await this.bitgo.decrypt({\n          input: backupKey,\n          password: params.walletPassphrase!,\n        });\n      } catch (e) {\n        throw new Error(`Error decrypting backup keychain: ${e.message}`);\n      }\n      const backupSigningMaterial = JSON.parse(backupPrv) as EDDSAMethodTypes.BackupSigningMaterial;\n\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      const signature = await signEddsaMpcV2RecoveryTx({\n        message: unsignedTransaction.signablePayload,\n        userKey,\n        backupKey,\n        walletPassphrase: params.walletPassphrase!,\n        bitgoKey,\n        derivationPath: currPath,\n        bitgo: this.bitgo,\n      });\n      txBuilder.addSignature({ pub: bs58EncodedPublicKey } as PublicKey, signature);\n    }\n  }\n\n  private async isMpcv2SigningMaterial(\n    userKey?: string,\n    backupKey?: string,\n    walletPassphrase?: string\n  ): Promise<boolean> {\n    if (!walletPassphrase) return false;\n    if (!userKey) throw new Error('missing userKey');\n    if (!backupKey) throw new Error('missing backupKey');\n    const material = await getEddsaSigningMaterial(userKey.replace(/\\s/g, ''), walletPassphrase, this.bitgo);\n    return material.version === 'v2';\n  }\n\n  async broadcastTransaction({\n    serializedSignedTransaction,\n  }: BaseBroadcastTransactionOptions): Promise<BaseBroadcastTransactionResult> {\n    let rawBytes: Buffer | undefined;\n    let isV1 = false;\n    try {\n      rawBytes = Buffer.from(serializedSignedTransaction, 'base64');\n      // v1 (SIMD-0296/0385) transactions start with the 0x81 version prefix.\n      isV1 = rawBytes.length > 0 && rawBytes[0] === 0x81;\n    } catch {\n      // Malformed or non-string input: not a v1 transaction. Fall through to the\n      // legacy validateRawTransaction path, which raises a descriptive error.\n    }\n\n    if (isV1) {\n      // Structural + signature validation parity with the legacy path (which uses\n      // validateRawTransaction(raw, true, true)). The 4096-byte v1 size limit is\n      // enforced inside validateRawTransactionV1 (parseWireTransaction).\n      validateRawTransactionV1(rawBytes!);\n    } else {\n      validateRawTransaction(serializedSignedTransaction, true, true);\n    }\n\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"]}