@bitgo-beta/sdk-coin-sol 7.6.4-beta.79 → 7.6.4-beta.790

package/dist/esm/lib/instructionParamsFactory.js

@@ -0,0 +1,1276 @@
+import { decodeTransferCheckedInstruction, decodeTransferCheckedWithFeeInstruction, decodeBurnInstruction, decodeMintToInstruction, TOKEN_2022_PROGRAM_ID, decodeApproveInstruction, TokenInstruction, TransferFeeInstruction, } from '@solana/spl-token';
+import { StakeInstruction, StakeProgram, SystemInstruction, ComputeBudgetInstruction, } from '@solana/web3.js';
+import { SolStakingTypeEnum } from '@bitgo/public-types';
+import { NotSupported, TransactionType } from '@bitgo-beta/sdk-core';
+import { coins, SolCoin } from '@bitgo-beta/statics';
+import assert from 'assert';
+import { InstructionBuilderTypes, ValidInstructionTypesEnum, walletInitInstructionIndexes } from './constants';
+import { getInstructionType } from './utils';
+import { decodeDepositSol, decodeWithdrawStake } from './jitoStakePoolOperations';
+/**
+ * Construct instructions params from Solana instructions
+ *
+ * @param {TransactionType} type - the transaction type
+ * @param {TransactionInstruction[]} instructions - solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params
+ */
+export function instructionParamsFactory(type, instructions, coinName, instructionMetadata, _useTokenAddressTokenName) {
+    switch (type) {
+        case TransactionType.WalletInitialization:
+            return parseWalletInitInstructions(instructions);
+        case TransactionType.Send:
+            return parseSendInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);
+        case TransactionType.StakingActivate:
+            return parseStakingActivateInstructions(instructions);
+        case TransactionType.StakingDeactivate:
+            return parseStakingDeactivateInstructions(instructions, coinName);
+        case TransactionType.StakingWithdraw:
+            return parseStakingWithdrawInstructions(instructions);
+        case TransactionType.AssociatedTokenAccountInitialization:
+            return parseAtaInitInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);
+        case TransactionType.CloseAssociatedTokenAccount:
+            return parseAtaCloseInstructions(instructions);
+        case TransactionType.StakingAuthorize:
+            return parseStakingAuthorizeInstructions(instructions);
+        case TransactionType.StakingAuthorizeRaw:
+            return parseStakingAuthorizeRawInstructions(instructions);
+        case TransactionType.StakingDelegate:
+            return parseStakingDelegateInstructions(instructions);
+        case TransactionType.CustomTx:
+            return parseCustomInstructions(instructions, instructionMetadata);
+        case TransactionType.ConfidentialTransfer:
+            return parseConfidentialTransferInstructions(instructions, instructionMetadata);
+        default:
+            throw new NotSupported('Invalid transaction, transaction type not supported: ' + type);
+    }
+}
+/**
+ * Parses Solana instructions to Wallet initialization tx instructions params
+ *
+ * @param {TransactionInstruction[]} instructions - containing create and initialize nonce solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for Wallet initialization tx
+ */
+function parseWalletInitInstructions(instructions) {
+    const instructionData = [];
+    // Compute-budget instructions can lead the transaction but are not part of the fixed
+    // wallet-init layout, so parse them apart from the indexed create/initialize instructions
+    const walletInitInstructions = instructions.filter((instruction) => !isComputeBudgetInstruction(instruction));
+    for (const instruction of instructions) {
+        if (isComputeBudgetInstruction(instruction)) {
+            instructionData.push(parseComputeBudgetInstruction(instruction));
+        }
+    }
+    const createInstruction = SystemInstruction.decodeCreateAccount(walletInitInstructions[walletInitInstructionIndexes.Create]);
+    const nonceInitInstruction = SystemInstruction.decodeNonceInitialize(walletInitInstructions[walletInitInstructionIndexes.InitializeNonceAccount]);
+    const walletInit = {
+        type: InstructionBuilderTypes.CreateNonceAccount,
+        params: {
+            fromAddress: createInstruction.fromPubkey.toString(),
+            nonceAddress: nonceInitInstruction.noncePubkey.toString(),
+            authAddress: nonceInitInstruction.authorizedPubkey.toString(),
+            amount: createInstruction.lamports.toString(),
+        },
+    };
+    instructionData.push(walletInit);
+    const memo = getMemo(walletInitInstructions, walletInitInstructionIndexes);
+    if (memo) {
+        instructionData.push(memo);
+    }
+    return instructionData;
+}
+/**
+ * Returns whether the instruction is a compute-budget instruction (SetComputeUnitLimit or
+ * SetPriorityFee), which can lead any transaction without affecting its type or layout.
+ *
+ * @param {TransactionInstruction} instruction - the instruction to be checked
+ * @returns {boolean} true if the instruction is a compute-budget instruction
+ */
+function isComputeBudgetInstruction(instruction) {
+    const type = getInstructionType(instruction);
+    return type === ValidInstructionTypesEnum.SetComputeUnitLimit || type === ValidInstructionTypesEnum.SetPriorityFee;
+}
+/**
+ * Parses a compute-budget instruction (SetComputeUnitLimit or SetPriorityFee) into its
+ * instructions params form.
+ *
+ * Compute-budget instructions are boilerplate that can lead any transaction, so every
+ * parser accepts them: initBuilder relies on them to restore the compute unit limit
+ * and the priority fee on a rebuild from raw, and explain filters them out.
+ *
+ * @param {TransactionInstruction} instruction - the compute-budget instruction to be parsed
+ * @returns {SetComputeUnitLimit | SetPriorityFee} the parsed instruction params
+ */
+function parseComputeBudgetInstruction(instruction) {
+    switch (getInstructionType(instruction)) {
+        case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            const setComputeUnitLimitParams = ComputeBudgetInstruction.decodeSetComputeUnitLimit(instruction);
+            return {
+                type: InstructionBuilderTypes.SetComputeUnitLimit,
+                params: {
+                    units: setComputeUnitLimitParams.units,
+                },
+            };
+        case ValidInstructionTypesEnum.SetPriorityFee:
+            const setComputeUnitPriceParams = ComputeBudgetInstruction.decodeSetComputeUnitPrice(instruction);
+            return {
+                type: InstructionBuilderTypes.SetPriorityFee,
+                params: {
+                    fee: setComputeUnitPriceParams.microLamports,
+                },
+            };
+        default:
+            throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+    }
+}
+/**
+ * Parses Solana instructions to Send tx instructions params
+ * Only supports Memo, Transfer and Advance Nonce Solana instructions
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for Send tx
+ */
+function parseSendInstructions(instructions, instructionMetadata, _useTokenAddressTokenName) {
+    const instructionData = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.Memo:
+                const memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };
+                instructionData.push(memo);
+                break;
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.Transfer:
+                const transferInstruction = SystemInstruction.decodeTransfer(instruction);
+                const transfer = {
+                    type: InstructionBuilderTypes.Transfer,
+                    params: {
+                        fromAddress: transferInstruction.fromPubkey.toString(),
+                        toAddress: transferInstruction.toPubkey.toString(),
+                        amount: transferInstruction.lamports.toString(),
+                    },
+                };
+                instructionData.push(transfer);
+                break;
+            case ValidInstructionTypesEnum.TokenTransfer:
+                const isToken2022Transfer = instruction.programId.toString() === TOKEN_2022_PROGRAM_ID.toString();
+                const isTransferWithFee = isToken2022Transfer &&
+                    instruction.data.length >= 2 &&
+                    instruction.data[0] === TokenInstruction.TransferFeeExtension &&
+                    instruction.data[1] === TransferFeeInstruction.TransferCheckedWithFee;
+                let ttKeys;
+                let ttAmount;
+                let ttDecimals;
+                let ttFee;
+                if (isTransferWithFee) {
+                    const decoded = decodeTransferCheckedWithFeeInstruction(instruction, TOKEN_2022_PROGRAM_ID);
+                    // WithFee exposes `authority` where TransferChecked exposes `owner`; normalize to owner.
+                    ttKeys = {
+                        source: decoded.keys.source,
+                        mint: decoded.keys.mint,
+                        destination: decoded.keys.destination,
+                        owner: decoded.keys.authority,
+                    };
+                    ttAmount = decoded.data.amount;
+                    ttDecimals = decoded.data.decimals;
+                    ttFee = decoded.data.fee.toString();
+                }
+                else {
+                    const decoded = decodeTransferCheckedInstruction(instruction, isToken2022Transfer ? TOKEN_2022_PROGRAM_ID : undefined);
+                    ttKeys = decoded.keys;
+                    ttAmount = decoded.data.amount;
+                    ttDecimals = decoded.data.decimals;
+                }
+                const tokenAddress = ttKeys.mint.pubkey.toString();
+                const tokenName = findTokenName(tokenAddress, instructionMetadata, _useTokenAddressTokenName);
+                let programIDForTokenTransfer;
+                if (instruction.programId) {
+                    programIDForTokenTransfer = instruction.programId.toString();
+                }
+                const transferHookAccounts = findTransferHookAccounts(ttKeys.owner.pubkey.toString(), ttKeys.destination.pubkey.toString(), tokenAddress, instructionMetadata);
+                const tokenTransfer = {
+                    type: InstructionBuilderTypes.TokenTransfer,
+                    params: {
+                        fromAddress: ttKeys.owner.pubkey.toString(),
+                        toAddress: ttKeys.destination.pubkey.toString(),
+                        amount: ttAmount.toString(),
+                        tokenName,
+                        sourceAddress: ttKeys.source.pubkey.toString(),
+                        tokenAddress: tokenAddress,
+                        programId: programIDForTokenTransfer,
+                        decimalPlaces: ttDecimals,
+                        ...(ttFee !== undefined ? { fee: ttFee } : {}),
+                        ...(transferHookAccounts ? { transferHookAccounts } : {}),
+                    },
+                };
+                instructionData.push(tokenTransfer);
+                break;
+            case ValidInstructionTypesEnum.Approve:
+                const programId = instruction.programId.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : undefined;
+                const approveInstruction = decodeApproveInstruction(instruction, programId);
+                const approve = {
+                    type: InstructionBuilderTypes.Approve,
+                    params: {
+                        accountAddress: approveInstruction.keys.account.toString(),
+                        delegateAddress: approveInstruction.keys.delegate.toString(),
+                        ownerAddress: approveInstruction.keys.owner.toString(),
+                        amount: approveInstruction.data.amount.toString(),
+                        programId: programId && programId.toString(),
+                    },
+                };
+                instructionData.push(approve);
+                break;
+            case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
+                const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
+                const mintTokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);
+                let programID;
+                if (instruction.programId) {
+                    programID = instruction.programId.toString();
+                }
+                const ataInit = {
+                    type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                    params: {
+                        mintAddress,
+                        ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),
+                        ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
+                        payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
+                        tokenName: mintTokenName,
+                        programId: programID,
+                    },
+                };
+                instructionData.push(ataInit);
+                break;
+            case ValidInstructionTypesEnum.CloseAssociatedTokenAccount:
+                const accountAddress = instruction.keys[closeAtaInstructionKeysIndexes.AccountAddress].pubkey.toString();
+                const destinationAddress = instruction.keys[closeAtaInstructionKeysIndexes.DestinationAddress].pubkey.toString();
+                const authorityAddress = instruction.keys[closeAtaInstructionKeysIndexes.AuthorityAddress].pubkey.toString();
+                const ataClose = {
+                    type: InstructionBuilderTypes.CloseAssociatedTokenAccount,
+                    params: {
+                        accountAddress,
+                        destinationAddress,
+                        authorityAddress,
+                        ...(instruction.programId.equals(TOKEN_2022_PROGRAM_ID)
+                            ? { programId: instruction.programId.toString() }
+                            : {}),
+                    },
+                };
+                instructionData.push(ataClose);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.MintTo:
+                let mintToInstruction;
+                if (instruction.programId.toString() !== TOKEN_2022_PROGRAM_ID.toString()) {
+                    mintToInstruction = decodeMintToInstruction(instruction);
+                }
+                else {
+                    mintToInstruction = decodeMintToInstruction(instruction, TOKEN_2022_PROGRAM_ID);
+                }
+                const mintAddressForMint = mintToInstruction.keys.mint.pubkey.toString();
+                const tokenNameForMint = findTokenName(mintAddressForMint, instructionMetadata, _useTokenAddressTokenName);
+                let programIDForMint;
+                if (instruction.programId) {
+                    programIDForMint = instruction.programId.toString();
+                }
+                const mintTo = {
+                    type: InstructionBuilderTypes.MintTo,
+                    params: {
+                        mintAddress: mintAddressForMint,
+                        destinationAddress: mintToInstruction.keys.destination.pubkey.toString(),
+                        authorityAddress: mintToInstruction.keys.authority.pubkey.toString(),
+                        amount: mintToInstruction.data.amount.toString(),
+                        tokenName: tokenNameForMint,
+                        decimalPlaces: undefined,
+                        programId: programIDForMint,
+                    },
+                };
+                instructionData.push(mintTo);
+                break;
+            case ValidInstructionTypesEnum.Burn:
+                let burnInstruction;
+                if (instruction.programId.toString() !== TOKEN_2022_PROGRAM_ID.toString()) {
+                    burnInstruction = decodeBurnInstruction(instruction);
+                }
+                else {
+                    burnInstruction = decodeBurnInstruction(instruction, TOKEN_2022_PROGRAM_ID);
+                }
+                const mintAddressForBurn = burnInstruction.keys.mint.pubkey.toString();
+                const tokenNameForBurn = findTokenName(mintAddressForBurn, instructionMetadata, _useTokenAddressTokenName);
+                let programIDForBurn;
+                if (instruction.programId) {
+                    programIDForBurn = instruction.programId.toString();
+                }
+                const burn = {
+                    type: InstructionBuilderTypes.Burn,
+                    params: {
+                        mintAddress: mintAddressForBurn,
+                        accountAddress: burnInstruction.keys.account.pubkey.toString(),
+                        authorityAddress: burnInstruction.keys.owner.pubkey.toString(),
+                        amount: burnInstruction.data.amount.toString(),
+                        tokenName: tokenNameForBurn,
+                        decimalPlaces: undefined,
+                        programId: programIDForBurn,
+                    },
+                };
+                instructionData.push(burn);
+                break;
+            case ValidInstructionTypesEnum.PermissionlessThawIdempotent:
+                // Account order matches the fixed layout emitted by solInstructionFactory:
+                // [authority, mint, tokenAccount, flagAccount, tokenAccountOwner, mintConfig,
+                //  tokenProgram, systemProgram, gatingProgram, ...extraAccounts].
+                const thawExtraAccounts = instruction.keys.slice(9).map((key) => ({
+                    pubkey: key.pubkey.toString(),
+                    isSigner: key.isSigner,
+                    isWritable: key.isWritable,
+                }));
+                const permissionlessThaw = {
+                    type: InstructionBuilderTypes.PermissionlessThawIdempotent,
+                    params: {
+                        authority: instruction.keys[0].pubkey.toString(),
+                        mint: instruction.keys[1].pubkey.toString(),
+                        tokenAccount: instruction.keys[2].pubkey.toString(),
+                        flagAccount: instruction.keys[3].pubkey.toString(),
+                        tokenAccountOwner: instruction.keys[4].pubkey.toString(),
+                        mintConfig: instruction.keys[5].pubkey.toString(),
+                        tokenProgram: instruction.keys[6].pubkey.toString(),
+                        systemProgram: instruction.keys[7].pubkey.toString(),
+                        gatingProgram: instruction.keys[8].pubkey.toString(),
+                        extraAccounts: thawExtraAccounts,
+                    },
+                };
+                instructionData.push(permissionlessThaw);
+                break;
+            default:
+                throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+        }
+    }
+    return instructionData;
+}
+function isJitoStakingInstructions(si) {
+    return si.depositSol !== undefined;
+}
+function isMarinadeStakingInstructions(si) {
+    return si.create !== undefined && si.initialize !== undefined && si.delegate === undefined;
+}
+function isNativeStakingInstructions(si) {
+    return si.create !== undefined && si.initialize !== undefined && si.delegate !== undefined;
+}
+function getStakingTypeFromStakingInstructions(si) {
+    const isJito = isJitoStakingInstructions(si);
+    const isMarinade = isMarinadeStakingInstructions(si);
+    const isNative = isNativeStakingInstructions(si);
+    assert([isJito, isMarinade, isNative].filter((x) => x).length === 1, 'StakingType is ambiguous');
+    if (isJito)
+        return SolStakingTypeEnum.JITO;
+    if (isMarinade)
+        return SolStakingTypeEnum.MARINADE;
+    if (isNative)
+        return SolStakingTypeEnum.NATIVE;
+    assert(false, 'No StakingType found');
+}
+/**
+ * Parses Solana instructions to create staking tx and delegate tx instructions params
+ * Only supports Nonce, StakingActivate and Memo Solana instructions
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking activate tx
+ */
+function parseStakingActivateInstructions(instructions) {
+    const instructionData = [];
+    const stakingInstructions = {};
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.Memo:
+                const memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };
+                instructionData.push(memo);
+                break;
+            case ValidInstructionTypesEnum.Create:
+                stakingInstructions.create = SystemInstruction.decodeCreateAccount(instruction);
+                break;
+            case ValidInstructionTypesEnum.StakingInitialize:
+                stakingInstructions.initialize = StakeInstruction.decodeInitialize(instruction);
+                break;
+            case ValidInstructionTypesEnum.StakingDelegate:
+                stakingInstructions.delegate = StakeInstruction.decodeDelegate(instruction);
+                break;
+            case ValidInstructionTypesEnum.DepositSol:
+                stakingInstructions.depositSol = decodeDepositSol(instruction);
+                break;
+            case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
+                stakingInstructions.hasAtaInit = true;
+                instructionData.push({
+                    type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                    params: {
+                        mintAddress: instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString(),
+                        ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),
+                        ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
+                        payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
+                        tokenName: findTokenName(instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString()),
+                    },
+                });
+                break;
+        }
+    }
+    validateStakingInstructions(stakingInstructions);
+    const stakingType = getStakingTypeFromStakingInstructions(stakingInstructions);
+    let stakingActivate;
+    switch (stakingType) {
+        case SolStakingTypeEnum.JITO: {
+            assert(isJitoStakingInstructions(stakingInstructions));
+            const { depositSol, hasAtaInit } = stakingInstructions;
+            stakingActivate = {
+                type: InstructionBuilderTypes.StakingActivate,
+                params: {
+                    stakingType,
+                    fromAddress: depositSol.fundingAccount.toString(),
+                    stakingAddress: depositSol.stakePool.toString(),
+                    amount: depositSol.lamports.toString(),
+                    validator: depositSol.stakePool.toString(),
+                    extraParams: {
+                        stakePoolData: {
+                            managerFeeAccount: depositSol.managerFeeAccount.toString(),
+                            poolMint: depositSol.poolMint.toString(),
+                            reserveStake: depositSol.reserveStake.toString(),
+                        },
+                        createAssociatedTokenAccount: !!hasAtaInit,
+                    },
+                },
+            };
+            break;
+        }
+        case SolStakingTypeEnum.MARINADE: {
+            assert(isMarinadeStakingInstructions(stakingInstructions));
+            const { create, initialize } = stakingInstructions;
+            stakingActivate = {
+                type: InstructionBuilderTypes.StakingActivate,
+                params: {
+                    stakingType,
+                    fromAddress: create.fromPubkey.toString(),
+                    stakingAddress: initialize.stakePubkey.toString(),
+                    amount: create.lamports.toString(),
+                    validator: initialize.authorized.staker.toString(),
+                },
+            };
+            break;
+        }
+        case SolStakingTypeEnum.NATIVE: {
+            assert(isNativeStakingInstructions(stakingInstructions));
+            const { create, initialize, delegate } = stakingInstructions;
+            stakingActivate = {
+                type: InstructionBuilderTypes.StakingActivate,
+                params: {
+                    stakingType,
+                    fromAddress: create.fromPubkey.toString(),
+                    stakingAddress: initialize.stakePubkey.toString(),
+                    amount: create.lamports.toString(),
+                    validator: delegate.votePubkey.toString(),
+                },
+            };
+            break;
+        }
+        default: {
+            const unreachable = stakingType;
+            throw new Error(`Unknown staking type ${unreachable}`);
+        }
+    }
+    instructionData.push(stakingActivate);
+    return instructionData;
+}
+/**
+ * Parses Solana instructions to create delegate tx
+ * Only supports Nonce, StakingDelegate
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking delegate tx
+ */
+function parseStakingDelegateInstructions(instructions) {
+    const instructionData = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.StakingDelegate:
+                const stakingDelegateParams = StakeInstruction.decodeDelegate(instruction);
+                const stakingDelegate = {
+                    type: InstructionBuilderTypes.StakingDelegate,
+                    params: {
+                        fromAddress: stakingDelegateParams.authorizedPubkey.toString() || '',
+                        stakingAddress: stakingDelegateParams.stakePubkey.toString() || '',
+                        validator: stakingDelegateParams.votePubkey.toString() || '',
+                    },
+                };
+                instructionData.push(stakingDelegate);
+                break;
+        }
+    }
+    return instructionData;
+}
+function validateStakingInstructions(stakingInstructions) {
+    if (stakingInstructions.delegate === undefined && stakingInstructions.depositSol !== undefined) {
+        return;
+    }
+    if (!stakingInstructions.create) {
+        throw new NotSupported('Invalid staking activate transaction, missing create stake account instruction');
+    }
+    if (!stakingInstructions.delegate && !stakingInstructions.initialize) {
+        throw new NotSupported('Invalid staking activate transaction, missing initialize stake account/delegate instruction');
+    }
+}
+function isJitoUnstakingInstructions(ui) {
+    return ui.withdrawStake !== undefined && ui.deactivate !== undefined;
+}
+function isMarinadeUnstakingInstructions(ui) {
+    return ui.transfer !== undefined && ui.deactivate === undefined;
+}
+function isNativeUnstakingInstructions(ui) {
+    return ui.withdrawStake === undefined && ui.deactivate !== undefined;
+}
+function getStakingTypeFromUnstakingInstructions(ui) {
+    const isJito = isJitoUnstakingInstructions(ui);
+    const isMarinade = isMarinadeUnstakingInstructions(ui);
+    const isNative = isNativeUnstakingInstructions(ui);
+    assert([isJito, isMarinade, isNative].filter((x) => x).length === 1, 'StakingType is ambiguous');
+    if (isJito)
+        return SolStakingTypeEnum.JITO;
+    if (isMarinade)
+        return SolStakingTypeEnum.MARINADE;
+    if (isNative)
+        return SolStakingTypeEnum.NATIVE;
+    assert(false, 'No StakingType found');
+}
+/**
+ * Parses Solana instructions to create deactivate stake tx instructions params. Supports full stake
+ * account deactivation and partial stake account deactivation.
+ *
+ * When partially deactivating a stake account this method expects the following instructions: Allocate,
+ * to allocate a new staking account, Assign, to assign the newly created staking account to the
+ * Stake Program, Split, to split the current stake account, and StakingDeactivate to deactivate the
+ * newly created stake account.
+ *
+ * Supports Nonce, StakingDeactivate, Memo, Allocate, Assign, and Split Solana instructions.
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking deactivate tx
+ */
+function parseStakingDeactivateInstructions(instructions, coinName) {
+    const instructionData = [];
+    const unstakingInstructions = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.Memo:
+                const memo = {
+                    type: InstructionBuilderTypes.Memo,
+                    params: { memo: instruction.data.toString() },
+                };
+                instructionData.push(memo);
+                break;
+            case ValidInstructionTypesEnum.Allocate:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].allocate === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].allocate =
+                        SystemInstruction.decodeAllocate(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        allocate: SystemInstruction.decodeAllocate(instruction),
+                    });
+                }
+                break;
+            case ValidInstructionTypesEnum.Assign:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].assign === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].assign = SystemInstruction.decodeAssign(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        assign: SystemInstruction.decodeAssign(instruction),
+                    });
+                }
+                break;
+            case ValidInstructionTypesEnum.Split:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].split === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].split = StakeInstruction.decodeSplit(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        split: StakeInstruction.decodeSplit(instruction),
+                    });
+                }
+                break;
+            case ValidInstructionTypesEnum.StakingDeactivate:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].deactivate === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].deactivate =
+                        StakeInstruction.decodeDeactivate(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        deactivate: StakeInstruction.decodeDeactivate(instruction),
+                    });
+                }
+                break;
+            case ValidInstructionTypesEnum.Transfer:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].transfer === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].transfer =
+                        SystemInstruction.decodeTransfer(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        transfer: SystemInstruction.decodeTransfer(instruction),
+                    });
+                }
+                break;
+            case ValidInstructionTypesEnum.WithdrawStake:
+                if (unstakingInstructions.length > 0 &&
+                    unstakingInstructions[unstakingInstructions.length - 1].withdrawStake === undefined) {
+                    unstakingInstructions[unstakingInstructions.length - 1].withdrawStake = decodeWithdrawStake(instruction);
+                }
+                else {
+                    unstakingInstructions.push({
+                        withdrawStake: decodeWithdrawStake(instruction),
+                    });
+                }
+                break;
+        }
+    }
+    for (const unstakingInstruction of unstakingInstructions) {
+        validateUnstakingInstructions(unstakingInstruction);
+        const stakingType = getStakingTypeFromUnstakingInstructions(unstakingInstruction);
+        let stakingDeactivate;
+        switch (stakingType) {
+            case SolStakingTypeEnum.JITO: {
+                assert(isJitoUnstakingInstructions(unstakingInstruction));
+                const { withdrawStake } = unstakingInstruction;
+                stakingDeactivate = {
+                    type: InstructionBuilderTypes.StakingDeactivate,
+                    params: {
+                        stakingType,
+                        fromAddress: withdrawStake.destinationStakeAuthority.toString(),
+                        stakingAddress: withdrawStake.stakePool.toString(),
+                        amount: withdrawStake.poolTokens.toString(),
+                        unstakingAddress: withdrawStake.destinationStake.toString(),
+                        extraParams: {
+                            stakePoolData: {
+                                managerFeeAccount: withdrawStake.managerFeeAccount.toString(),
+                                poolMint: withdrawStake.poolMint.toString(),
+                                validatorListAccount: withdrawStake.validatorList.toString(),
+                            },
+                            validatorAddress: withdrawStake.validatorStake.toString(),
+                            transferAuthorityAddress: withdrawStake.sourceTransferAuthority.toString(),
+                        },
+                    },
+                };
+                break;
+            }
+            case SolStakingTypeEnum.MARINADE: {
+                assert(isMarinadeUnstakingInstructions(unstakingInstruction));
+                const { transfer } = unstakingInstruction;
+                stakingDeactivate = {
+                    type: InstructionBuilderTypes.StakingDeactivate,
+                    params: {
+                        stakingType,
+                        fromAddress: '',
+                        stakingAddress: '',
+                        recipients: [
+                            {
+                                address: transfer.toPubkey.toString() || '',
+                                amount: transfer.lamports.toString() || '',
+                            },
+                        ],
+                    },
+                };
+                break;
+            }
+            case SolStakingTypeEnum.NATIVE: {
+                assert(isNativeUnstakingInstructions(unstakingInstruction));
+                const { deactivate, split } = unstakingInstruction;
+                stakingDeactivate = {
+                    type: InstructionBuilderTypes.StakingDeactivate,
+                    params: {
+                        stakingType,
+                        fromAddress: deactivate.authorizedPubkey.toString() || '',
+                        stakingAddress: split?.stakePubkey.toString() || deactivate.stakePubkey.toString(),
+                        amount: split?.lamports.toString(),
+                        unstakingAddress: split?.splitStakePubkey.toString(),
+                    },
+                };
+                break;
+            }
+            default: {
+                const unreachable = stakingType;
+                throw new Error(`Unknown staking type ${unreachable}`);
+            }
+        }
+        instructionData.push(stakingDeactivate);
+    }
+    return instructionData;
+}
+function validateUnstakingInstructions(unstakingInstructions) {
+    // Cases where exactly one field should be present
+    const unstakingInstructionsKeys = [
+        'allocate',
+        'assign',
+        'split',
+        'deactivate',
+        'transfer',
+    ];
+    if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'transfer'))) {
+        return;
+    }
+    if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'withdrawStake'))) {
+        return;
+    }
+    if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'deactivate'))) {
+        return;
+    }
+    // Cases where deactivate field must be present with another field
+    if (!unstakingInstructions.deactivate) {
+        throw new NotSupported('Invalid deactivate stake transaction, missing deactivate stake account instruction');
+    }
+    // This is a stake pool instruction, not a partial unstake
+    if (unstakingInstructions.withdrawStake) {
+        return;
+    }
+    if (!unstakingInstructions.allocate) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, missing allocate unstake account instruction');
+    }
+    else if (!unstakingInstructions.assign) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, missing assign unstake account instruction');
+    }
+    else if (!unstakingInstructions.split) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, missing split stake account instruction');
+    }
+    else if (unstakingInstructions.allocate.accountPubkey.toString() !== unstakingInstructions.assign.accountPubkey.toString()) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, must allocate and assign the same public key');
+    }
+    else if (unstakingInstructions.allocate.space !== StakeProgram.space) {
+        throw new NotSupported(`Invalid partial deactivate stake transaction, unstaking account must allocate ${StakeProgram.space} bytes`);
+    }
+    else if (unstakingInstructions.assign.programId.toString() !== StakeProgram.programId.toString()) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, the unstake account must be assigned to the Stake Program');
+    }
+    else if (unstakingInstructions.allocate.accountPubkey.toString() !== unstakingInstructions.split.splitStakePubkey.toString()) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, must allocate the unstaking account');
+    }
+    else if (unstakingInstructions.split.stakePubkey.toString() === unstakingInstructions.split.splitStakePubkey.toString()) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, the unstaking account must be different from the Stake Account');
+    }
+    else if (!unstakingInstructions.transfer) {
+        throw new NotSupported('Invalid partial deactivate stake transaction, missing funding of unstake address instruction');
+    }
+}
+/**
+ * Parses Solana instructions to create staking  withdraw tx instructions params
+ * Only supports Nonce, StakingWithdraw, and Memo Solana instructions
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking withdraw tx
+ */
+function parseStakingWithdrawInstructions(instructions) {
+    const instructionData = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.Memo:
+                const memo = {
+                    type: InstructionBuilderTypes.Memo,
+                    params: { memo: instruction.data.toString() },
+                };
+                instructionData.push(memo);
+                break;
+            case ValidInstructionTypesEnum.StakingWithdraw:
+                const withdrawInstruction = StakeInstruction.decodeWithdraw(instruction);
+                const stakingWithdraw = {
+                    type: InstructionBuilderTypes.StakingWithdraw,
+                    params: {
+                        fromAddress: withdrawInstruction.authorizedPubkey.toString(),
+                        stakingAddress: withdrawInstruction.stakePubkey.toString(),
+                        amount: withdrawInstruction.lamports.toString(),
+                    },
+                };
+                instructionData.push(stakingWithdraw);
+                break;
+        }
+    }
+    return instructionData;
+}
+/**
+ * Get the memo object from instructions if it exists
+ *
+ * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed
+ * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction
+ * @returns {Memo | undefined} - memo object or undefined
+ */
+function getMemo(instructions, instructionIndexes) {
+    const instructionsLength = Object.keys(instructionIndexes).length;
+    if (instructions.length === instructionsLength && instructions[instructionIndexes.Memo]) {
+        return {
+            type: InstructionBuilderTypes.Memo,
+            params: { memo: instructions[instructionIndexes.Memo].data.toString() },
+        };
+    }
+}
+const ataInitInstructionKeysIndexes = {
+    PayerAddress: 0,
+    ATAAddress: 1,
+    OwnerAddress: 2,
+    MintAddress: 3,
+};
+const closeAtaInstructionKeysIndexes = {
+    AccountAddress: 0,
+    DestinationAddress: 1,
+    AuthorityAddress: 2,
+};
+/**
+ * Parses Solana instructions to initialize associated token account tx instructions params
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for Send tx
+ */
+function parseAtaInitInstructions(instructions, instructionMetadata, _useTokenAddressTokenName) {
+    const instructionData = [];
+    let memo;
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.Memo:
+                memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };
+                break;
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:
+                const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();
+                const tokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);
+                let programID;
+                if (instruction.programId) {
+                    programID = instruction.programId.toString();
+                }
+                const ataInit = {
+                    type: InstructionBuilderTypes.CreateAssociatedTokenAccount,
+                    params: {
+                        mintAddress,
+                        ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),
+                        ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),
+                        payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),
+                        tokenName,
+                        programId: programID,
+                    },
+                };
+                instructionData.push(ataInit);
+                break;
+            case ValidInstructionTypesEnum.PermissionlessThawIdempotent:
+                const thawExtraAccounts = instruction.keys.slice(9).map((key) => ({
+                    pubkey: key.pubkey.toString(),
+                    isSigner: key.isSigner,
+                    isWritable: key.isWritable,
+                }));
+                const permissionlessThaw = {
+                    type: InstructionBuilderTypes.PermissionlessThawIdempotent,
+                    params: {
+                        authority: instruction.keys[0].pubkey.toString(),
+                        mint: instruction.keys[1].pubkey.toString(),
+                        tokenAccount: instruction.keys[2].pubkey.toString(),
+                        flagAccount: instruction.keys[3].pubkey.toString(),
+                        tokenAccountOwner: instruction.keys[4].pubkey.toString(),
+                        mintConfig: instruction.keys[5].pubkey.toString(),
+                        tokenProgram: instruction.keys[6].pubkey.toString(),
+                        systemProgram: instruction.keys[7].pubkey.toString(),
+                        gatingProgram: instruction.keys[8].pubkey.toString(),
+                        extraAccounts: thawExtraAccounts,
+                    },
+                };
+                instructionData.push(permissionlessThaw);
+                break;
+            case ValidInstructionTypesEnum.DepositSol:
+                // AtaInit is a part of spl-stake-pool's depositSol process
+                break;
+            default:
+                throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+        }
+    }
+    if (memo) {
+        instructionData.push(memo);
+    }
+    return instructionData;
+}
+const ataCloseInstructionKeysIndexes = {
+    AccountAddress: 0,
+    DestinationAddress: 1,
+    AuthorityAddress: 2,
+};
+const ataRecoverNestedInstructionKeysIndexes = {
+    NestedAccountAddress: 0,
+    NestedMintAddress: 1,
+    DestinationAccountAddress: 2,
+    OwnerAccountAddress: 3,
+    OwnerMintAddress: 4,
+    WalletAddress: 5,
+};
+/**
+ * Parses Solana instructions to close associated token account tx instructions params
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for Send tx
+ */
+function parseAtaCloseInstructions(instructions) {
+    const instructionData = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.SetComputeUnitLimit:
+            case ValidInstructionTypesEnum.SetPriorityFee:
+                instructionData.push(parseComputeBudgetInstruction(instruction));
+                break;
+            case ValidInstructionTypesEnum.CloseAssociatedTokenAccount:
+                const ataClose = {
+                    type: InstructionBuilderTypes.CloseAssociatedTokenAccount,
+                    params: {
+                        accountAddress: instruction.keys[ataCloseInstructionKeysIndexes.AccountAddress].pubkey.toString(),
+                        destinationAddress: instruction.keys[ataCloseInstructionKeysIndexes.DestinationAddress].pubkey.toString(),
+                        authorityAddress: instruction.keys[ataCloseInstructionKeysIndexes.AuthorityAddress].pubkey.toString(),
+                        ...(instruction.programId.equals(TOKEN_2022_PROGRAM_ID)
+                            ? { programId: instruction.programId.toString() }
+                            : {}),
+                    },
+                };
+                instructionData.push(ataClose);
+                break;
+            case ValidInstructionTypesEnum.RecoverNestedAssociatedTokenAccount:
+                const ataRecoverNested = {
+                    type: InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount,
+                    params: {
+                        nestedAccountAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.NestedAccountAddress].pubkey.toString(),
+                        nestedMintAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.NestedMintAddress].pubkey.toString(),
+                        destinationAccountAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.DestinationAccountAddress].pubkey.toString(),
+                        ownerAccountAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.OwnerAccountAddress].pubkey.toString(),
+                        ownerMintAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.OwnerMintAddress].pubkey.toString(),
+                        walletAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.WalletAddress].pubkey.toString(),
+                    },
+                };
+                instructionData.push(ataRecoverNested);
+                break;
+            default:
+                throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+        }
+    }
+    return instructionData;
+}
+/**
+ * Parses Solana instructions to authorized staking account params
+ * Only supports Nonce, Authorize instructions
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking authorize tx
+ */
+function parseStakingAuthorizeInstructions(instructions) {
+    const instructionData = [];
+    for (const instruction of instructions) {
+        const type = getInstructionType(instruction);
+        switch (type) {
+            case ValidInstructionTypesEnum.AdvanceNonceAccount:
+                const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);
+                const nonce = {
+                    type: InstructionBuilderTypes.NonceAdvance,
+                    params: {
+                        walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+                        authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+                    },
+                };
+                instructionData.push(nonce);
+                break;
+            case ValidInstructionTypesEnum.Memo:
+                const memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };
+                instructionData.push(memo);
+                break;
+            case ValidInstructionTypesEnum.Authorize:
+                const authorize = StakeInstruction.decodeAuthorize(instruction);
+                instructionData.push({
+                    type: InstructionBuilderTypes.StakingAuthorize,
+                    params: {
+                        stakingAddress: authorize.stakePubkey.toString(),
+                        oldAuthorizeAddress: authorize.authorizedPubkey.toString(),
+                        newAuthorizeAddress: authorize.newAuthorizedPubkey.toString(),
+                        newWithdrawAddress: authorize.custodianPubkey?.toString() || '',
+                    },
+                });
+                break;
+        }
+    }
+    return instructionData;
+}
+/**
+ * Parses Solana instructions to authorized staking account params
+ * Only supports Nonce, Authorize instructions
+ *
+ * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions
+ * @returns {InstructionParams[]} An array containing instruction params for staking authorize tx
+ */
+function parseStakingAuthorizeRawInstructions(instructions) {
+    const instructionData = [];
+    assert(instructions.length === 2, 'Invalid number of instructions');
+    const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instructions[0]);
+    const nonce = {
+        type: InstructionBuilderTypes.NonceAdvance,
+        params: {
+            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),
+            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),
+        },
+    };
+    instructionData.push(nonce);
+    const authorize = instructions[1];
+    assert(authorize.keys.length === 5, 'Invalid number of keys in authorize instruction');
+    instructionData.push({
+        type: InstructionBuilderTypes.StakingAuthorize,
+        params: {
+            stakingAddress: authorize.keys[0].pubkey.toString(),
+            oldAuthorizeAddress: authorize.keys[2].pubkey.toString(),
+            newAuthorizeAddress: authorize.keys[3].pubkey.toString(),
+            custodianAddress: authorize.keys[4].pubkey.toString(),
+        },
+    });
+    return instructionData;
+}
+/**
+ * Returns true if the instruction type is a confidential transfer instruction
+ * (Token-2022 CT extension or zk-elgamal-proof program).
+ */
+function isConfidentialTransferInstruction(type) {
+    switch (type) {
+        case InstructionBuilderTypes.ConfigureConfidentialTransferAccount:
+        case InstructionBuilderTypes.ApplyPendingBalance:
+        case InstructionBuilderTypes.ConfidentialDeposit:
+        case InstructionBuilderTypes.ConfidentialWithdraw:
+        case InstructionBuilderTypes.ConfidentialTransfer:
+        case InstructionBuilderTypes.VerifyPubkeyValidity:
+        case InstructionBuilderTypes.VerifyEqualityProof:
+        case InstructionBuilderTypes.VerifyValidityProof:
+        case InstructionBuilderTypes.VerifyRangeProof:
+        case InstructionBuilderTypes.ReallocateConfidentialTransferAccount:
+            return true;
+        default:
+            return false;
+    }
+}
+/**
+ * Parses Solana instructions to custom instruction params
+ *
+ * @param {TransactionInstruction[]} instructions - containing custom solana instructions
+ * @param {InstructionParams[]} instructionMetadata - the instruction metadata for the transaction
+ * @returns {InstructionParams[]} An array containing instruction params for custom instructions
+ */
+function parseCustomInstructions(instructions, instructionMetadata) {
+    const instructionData = [];
+    for (let i = 0; i < instructions.length; i++) {
+        const instruction = instructions[i];
+        // Check if we have metadata for this instruction position
+        if (instructionMetadata &&
+            instructionMetadata[i] &&
+            instructionMetadata[i].type === InstructionBuilderTypes.CustomInstruction) {
+            instructionData.push(instructionMetadata[i]);
+        }
+        else {
+            // Convert the raw instruction to CustomInstruction format
+            const customInstruction = {
+                type: InstructionBuilderTypes.CustomInstruction,
+                params: {
+                    programId: instruction.programId.toString(),
+                    keys: instruction.keys.map((key) => ({
+                        pubkey: key.pubkey.toString(),
+                        isSigner: key.isSigner,
+                        isWritable: key.isWritable,
+                    })),
+                    data: instruction.data.toString('base64'),
+                },
+            };
+            instructionData.push(customInstruction);
+        }
+    }
+    return instructionData;
+}
+/**
+ * Parses Solana instructions to confidential transfer instruction params.
+ *
+ * Iterates raw instructions in order, checking metadata at each position:
+ * - CT instruction metadata is preserved as-is (CT instructions cannot be
+ *   decoded by @solana/spl-token or @solana/web3.js).
+ * - CustomInstruction metadata is preserved as-is.
+ * - All other instructions fall back to CustomInstruction format with raw
+ *   programId/keys/data.
+ *
+ * This single-pass approach preserves original instruction order so that
+ * round-trip reconstruction is faithful.
+ *
+ * @param {TransactionInstruction[]} instructions - containing CT solana instructions
+ * @param {InstructionParams[]} instructionMetadata - the instruction metadata for the transaction
+ * @returns {InstructionParams[]} An array containing instruction params in original order
+ */
+function parseConfidentialTransferInstructions(instructions, instructionMetadata) {
+    const instructionData = [];
+    for (let i = 0; i < instructions.length; i++) {
+        const instruction = instructions[i];
+        // Check if we have metadata for this instruction position
+        if (instructionMetadata && instructionMetadata[i]) {
+            const metaType = instructionMetadata[i].type;
+            // Preserve confidential transfer, custom, and ATA-init metadata as-is
+            // (CT enablement txs carry CreateATA + ConfigureAccount + proofs).
+            if (isConfidentialTransferInstruction(metaType) ||
+                metaType === InstructionBuilderTypes.CustomInstruction ||
+                metaType === InstructionBuilderTypes.CreateAssociatedTokenAccount) {
+                instructionData.push(instructionMetadata[i]);
+                continue;
+            }
+        }
+        // Convert the raw instruction to CustomInstruction format
+        const customInstruction = {
+            type: InstructionBuilderTypes.CustomInstruction,
+            params: {
+                programId: instruction.programId.toString(),
+                keys: instruction.keys.map((key) => ({
+                    pubkey: key.pubkey.toString(),
+                    isSigner: key.isSigner,
+                    isWritable: key.isWritable,
+                })),
+                data: instruction.data.toString('base64'),
+            },
+        };
+        instructionData.push(customInstruction);
+    }
+    return instructionData;
+}
+export function findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName) {
+    let token;
+    coins.forEach((value, key) => {
+        if (value instanceof SolCoin && value.tokenAddress === mintAddress) {
+            token = value.name;
+        }
+    });
+    if (!token && instructionMetadata) {
+        instructionMetadata.forEach((instruction) => {
+            if (instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount &&
+                instruction.params.mintAddress === mintAddress) {
+                token = instruction.params.tokenName;
+            }
+            else if (instruction.type === InstructionBuilderTypes.TokenTransfer &&
+                instruction.params.tokenAddress === mintAddress) {
+                token = instruction.params.tokenName;
+            }
+        });
+    }
+    if (!token && _useTokenAddressTokenName) {
+        token = mintAddress;
+    }
+    assert(token);
+    return token;
+}
+export function findTransferHookAccounts(fromAddress, toAddress, tokenAddress, instructionMetadata) {
+    let transferHookAccounts;
+    instructionMetadata?.forEach((instruction) => {
+        if (instruction.type === InstructionBuilderTypes.TokenTransfer &&
+            instruction.params.tokenAddress === tokenAddress &&
+            instruction.params.fromAddress === fromAddress &&
+            instruction.params.toAddress === toAddress) {
+            transferHookAccounts = instruction.params.transferHookAccounts;
+        }
+    });
+    return transferHookAccounts;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"instructionParamsFactory.js","sourceRoot":"","sources":["../../../src/lib/instructionParamsFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  DecodedTransferCheckedInstruction,\n  decodeTransferCheckedInstruction,\n  decodeTransferCheckedWithFeeInstruction,\n  DecodedBurnInstruction,\n  decodeBurnInstruction,\n  DecodedMintToInstruction,\n  decodeMintToInstruction,\n  TOKEN_2022_PROGRAM_ID,\n  decodeApproveInstruction,\n  TokenInstruction,\n  TransferFeeInstruction,\n} from '@solana/spl-token';\nimport {\n  AllocateParams,\n  AssignParams,\n  CreateAccountParams,\n  DeactivateStakeParams,\n  DecodedTransferInstruction,\n  DelegateStakeParams,\n  InitializeStakeParams,\n  SplitStakeParams,\n  StakeInstruction,\n  StakeProgram,\n  SystemInstruction,\n  TransactionInstruction,\n  ComputeBudgetInstruction,\n} from '@solana/web3.js';\n\nimport { SolStakingTypeEnum } from '@bitgo/public-types';\nimport { NotSupported, TransactionType } from '@bitgo-beta/sdk-core';\nimport { coins, SolCoin } from '@bitgo-beta/statics';\nimport assert from 'assert';\nimport { InstructionBuilderTypes, ValidInstructionTypesEnum, walletInitInstructionIndexes } from './constants';\nimport {\n  AtaClose,\n  AtaInit,\n  AtaRecoverNested,\n  Burn,\n  ExtraAccountMeta,\n  InstructionParams,\n  Memo,\n  MintTo,\n  Nonce,\n  PermissionlessThawIdempotent,\n  StakingActivate,\n  StakingAuthorize,\n  StakingDeactivate,\n  StakingDelegate,\n  StakingWithdraw,\n  TokenTransfer,\n  Transfer,\n  WalletInit,\n  SetComputeUnitLimit,\n  SetPriorityFee,\n  CustomInstruction,\n  Approve,\n} from './iface';\nimport { getInstructionType } from './utils';\nimport { DepositSolParams, WithdrawStakeParams } from '@solana/spl-stake-pool';\nimport { decodeDepositSol, decodeWithdrawStake } from './jitoStakePoolOperations';\n\n/**\n * Construct instructions params from Solana instructions\n *\n * @param {TransactionType} type - the transaction type\n * @param {TransactionInstruction[]} instructions - solana instructions\n * @returns {InstructionParams[]} An array containing instruction params\n */\nexport function instructionParamsFactory(\n  type: TransactionType,\n  instructions: TransactionInstruction[],\n  coinName?: string,\n  instructionMetadata?: InstructionParams[],\n  _useTokenAddressTokenName?: boolean\n): InstructionParams[] {\n  switch (type) {\n    case TransactionType.WalletInitialization:\n      return parseWalletInitInstructions(instructions);\n    case TransactionType.Send:\n      return parseSendInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);\n    case TransactionType.StakingActivate:\n      return parseStakingActivateInstructions(instructions);\n    case TransactionType.StakingDeactivate:\n      return parseStakingDeactivateInstructions(instructions, coinName);\n    case TransactionType.StakingWithdraw:\n      return parseStakingWithdrawInstructions(instructions);\n    case TransactionType.AssociatedTokenAccountInitialization:\n      return parseAtaInitInstructions(instructions, instructionMetadata, _useTokenAddressTokenName);\n    case TransactionType.CloseAssociatedTokenAccount:\n      return parseAtaCloseInstructions(instructions);\n    case TransactionType.StakingAuthorize:\n      return parseStakingAuthorizeInstructions(instructions);\n    case TransactionType.StakingAuthorizeRaw:\n      return parseStakingAuthorizeRawInstructions(instructions);\n    case TransactionType.StakingDelegate:\n      return parseStakingDelegateInstructions(instructions);\n    case TransactionType.CustomTx:\n      return parseCustomInstructions(instructions, instructionMetadata);\n    case TransactionType.ConfidentialTransfer:\n      return parseConfidentialTransferInstructions(instructions, instructionMetadata);\n    default:\n      throw new NotSupported('Invalid transaction, transaction type not supported: ' + type);\n  }\n}\n\n/**\n * Parses Solana instructions to Wallet initialization tx instructions params\n *\n * @param {TransactionInstruction[]} instructions - containing create and initialize nonce solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for Wallet initialization tx\n */\nfunction parseWalletInitInstructions(\n  instructions: TransactionInstruction[]\n): Array<WalletInit | Memo | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<WalletInit | Memo | SetComputeUnitLimit | SetPriorityFee> = [];\n  // Compute-budget instructions can lead the transaction but are not part of the fixed\n  // wallet-init layout, so parse them apart from the indexed create/initialize instructions\n  const walletInitInstructions = instructions.filter((instruction) => !isComputeBudgetInstruction(instruction));\n  for (const instruction of instructions) {\n    if (isComputeBudgetInstruction(instruction)) {\n      instructionData.push(parseComputeBudgetInstruction(instruction));\n    }\n  }\n  const createInstruction = SystemInstruction.decodeCreateAccount(\n    walletInitInstructions[walletInitInstructionIndexes.Create]\n  );\n  const nonceInitInstruction = SystemInstruction.decodeNonceInitialize(\n    walletInitInstructions[walletInitInstructionIndexes.InitializeNonceAccount]\n  );\n\n  const walletInit: WalletInit = {\n    type: InstructionBuilderTypes.CreateNonceAccount,\n    params: {\n      fromAddress: createInstruction.fromPubkey.toString(),\n      nonceAddress: nonceInitInstruction.noncePubkey.toString(),\n      authAddress: nonceInitInstruction.authorizedPubkey.toString(),\n      amount: createInstruction.lamports.toString(),\n    },\n  };\n  instructionData.push(walletInit);\n\n  const memo = getMemo(walletInitInstructions, walletInitInstructionIndexes);\n  if (memo) {\n    instructionData.push(memo);\n  }\n\n  return instructionData;\n}\n\n/**\n * Returns whether the instruction is a compute-budget instruction (SetComputeUnitLimit or\n * SetPriorityFee), which can lead any transaction without affecting its type or layout.\n *\n * @param {TransactionInstruction} instruction - the instruction to be checked\n * @returns {boolean} true if the instruction is a compute-budget instruction\n */\nfunction isComputeBudgetInstruction(instruction: TransactionInstruction): boolean {\n  const type = getInstructionType(instruction);\n  return type === ValidInstructionTypesEnum.SetComputeUnitLimit || type === ValidInstructionTypesEnum.SetPriorityFee;\n}\n\n/**\n * Parses a compute-budget instruction (SetComputeUnitLimit or SetPriorityFee) into its\n * instructions params form.\n *\n * Compute-budget instructions are boilerplate that can lead any transaction, so every\n * parser accepts them: initBuilder relies on them to restore the compute unit limit\n * and the priority fee on a rebuild from raw, and explain filters them out.\n *\n * @param {TransactionInstruction} instruction - the compute-budget instruction to be parsed\n * @returns {SetComputeUnitLimit | SetPriorityFee} the parsed instruction params\n */\nfunction parseComputeBudgetInstruction(instruction: TransactionInstruction): SetComputeUnitLimit | SetPriorityFee {\n  switch (getInstructionType(instruction)) {\n    case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      const setComputeUnitLimitParams = ComputeBudgetInstruction.decodeSetComputeUnitLimit(instruction);\n      return {\n        type: InstructionBuilderTypes.SetComputeUnitLimit,\n        params: {\n          units: setComputeUnitLimitParams.units,\n        },\n      };\n    case ValidInstructionTypesEnum.SetPriorityFee:\n      const setComputeUnitPriceParams = ComputeBudgetInstruction.decodeSetComputeUnitPrice(instruction);\n      return {\n        type: InstructionBuilderTypes.SetPriorityFee,\n        params: {\n          fee: setComputeUnitPriceParams.microLamports,\n        },\n      };\n    default:\n      throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));\n  }\n}\n\n/**\n * Parses Solana instructions to Send tx instructions params\n * Only supports Memo, Transfer and Advance Nonce Solana instructions\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for Send tx\n */\nfunction parseSendInstructions(\n  instructions: TransactionInstruction[],\n  instructionMetadata?: InstructionParams[],\n  _useTokenAddressTokenName?: boolean\n): Array<\n  | Nonce\n  | Memo\n  | Transfer\n  | TokenTransfer\n  | AtaInit\n  | AtaClose\n  | SetComputeUnitLimit\n  | SetPriorityFee\n  | MintTo\n  | Burn\n  | Approve\n  | PermissionlessThawIdempotent\n> {\n  const instructionData: Array<\n    | Nonce\n    | Memo\n    | Transfer\n    | TokenTransfer\n    | AtaInit\n    | AtaClose\n    | SetComputeUnitLimit\n    | SetPriorityFee\n    | MintTo\n    | Burn\n    | Approve\n    | PermissionlessThawIdempotent\n  > = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.Memo:\n        const memo: Memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };\n        instructionData.push(memo);\n        break;\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n      case ValidInstructionTypesEnum.Transfer:\n        const transferInstruction = SystemInstruction.decodeTransfer(instruction);\n        const transfer: Transfer = {\n          type: InstructionBuilderTypes.Transfer,\n          params: {\n            fromAddress: transferInstruction.fromPubkey.toString(),\n            toAddress: transferInstruction.toPubkey.toString(),\n            amount: transferInstruction.lamports.toString(),\n          },\n        };\n        instructionData.push(transfer);\n        break;\n      case ValidInstructionTypesEnum.TokenTransfer:\n        const isToken2022Transfer = instruction.programId.toString() === TOKEN_2022_PROGRAM_ID.toString();\n        const isTransferWithFee =\n          isToken2022Transfer &&\n          instruction.data.length >= 2 &&\n          instruction.data[0] === TokenInstruction.TransferFeeExtension &&\n          instruction.data[1] === TransferFeeInstruction.TransferCheckedWithFee;\n        let ttKeys: DecodedTransferCheckedInstruction['keys'];\n        let ttAmount: bigint;\n        let ttDecimals: number;\n        let ttFee: string | undefined;\n        if (isTransferWithFee) {\n          const decoded = decodeTransferCheckedWithFeeInstruction(instruction, TOKEN_2022_PROGRAM_ID);\n          // WithFee exposes `authority` where TransferChecked exposes `owner`; normalize to owner.\n          ttKeys = {\n            source: decoded.keys.source,\n            mint: decoded.keys.mint,\n            destination: decoded.keys.destination,\n            owner: decoded.keys.authority,\n          } as DecodedTransferCheckedInstruction['keys'];\n          ttAmount = decoded.data.amount;\n          ttDecimals = decoded.data.decimals;\n          ttFee = decoded.data.fee.toString();\n        } else {\n          const decoded = decodeTransferCheckedInstruction(\n            instruction,\n            isToken2022Transfer ? TOKEN_2022_PROGRAM_ID : undefined\n          );\n          ttKeys = decoded.keys;\n          ttAmount = decoded.data.amount;\n          ttDecimals = decoded.data.decimals;\n        }\n        const tokenAddress = ttKeys.mint.pubkey.toString();\n        const tokenName = findTokenName(tokenAddress, instructionMetadata, _useTokenAddressTokenName);\n        let programIDForTokenTransfer: string | undefined;\n        if (instruction.programId) {\n          programIDForTokenTransfer = instruction.programId.toString();\n        }\n        const transferHookAccounts = findTransferHookAccounts(\n          ttKeys.owner.pubkey.toString(),\n          ttKeys.destination.pubkey.toString(),\n          tokenAddress,\n          instructionMetadata\n        );\n        const tokenTransfer: TokenTransfer = {\n          type: InstructionBuilderTypes.TokenTransfer,\n          params: {\n            fromAddress: ttKeys.owner.pubkey.toString(),\n            toAddress: ttKeys.destination.pubkey.toString(),\n            amount: ttAmount.toString(),\n            tokenName,\n            sourceAddress: ttKeys.source.pubkey.toString(),\n            tokenAddress: tokenAddress,\n            programId: programIDForTokenTransfer,\n            decimalPlaces: ttDecimals,\n            ...(ttFee !== undefined ? { fee: ttFee } : {}),\n            ...(transferHookAccounts ? { transferHookAccounts } : {}),\n          },\n        };\n        instructionData.push(tokenTransfer);\n        break;\n      case ValidInstructionTypesEnum.Approve:\n        const programId = instruction.programId.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : undefined;\n        const approveInstruction = decodeApproveInstruction(instruction, programId);\n        const approve: Approve = {\n          type: InstructionBuilderTypes.Approve,\n          params: {\n            accountAddress: approveInstruction.keys.account.toString(),\n            delegateAddress: approveInstruction.keys.delegate.toString(),\n            ownerAddress: approveInstruction.keys.owner.toString(),\n            amount: approveInstruction.data.amount.toString(),\n            programId: programId && programId.toString(),\n          },\n        };\n        instructionData.push(approve);\n        break;\n      case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:\n        const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();\n        const mintTokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);\n        let programID: string | undefined;\n        if (instruction.programId) {\n          programID = instruction.programId.toString();\n        }\n\n        const ataInit: AtaInit = {\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            mintAddress,\n            ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),\n            ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),\n            payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),\n            tokenName: mintTokenName,\n            programId: programID,\n          },\n        };\n        instructionData.push(ataInit);\n        break;\n      case ValidInstructionTypesEnum.CloseAssociatedTokenAccount:\n        const accountAddress = instruction.keys[closeAtaInstructionKeysIndexes.AccountAddress].pubkey.toString();\n        const destinationAddress =\n          instruction.keys[closeAtaInstructionKeysIndexes.DestinationAddress].pubkey.toString();\n        const authorityAddress = instruction.keys[closeAtaInstructionKeysIndexes.AuthorityAddress].pubkey.toString();\n\n        const ataClose: AtaClose = {\n          type: InstructionBuilderTypes.CloseAssociatedTokenAccount,\n          params: {\n            accountAddress,\n            destinationAddress,\n            authorityAddress,\n            ...(instruction.programId.equals(TOKEN_2022_PROGRAM_ID)\n              ? { programId: instruction.programId.toString() }\n              : {}),\n          },\n        };\n        instructionData.push(ataClose);\n        break;\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n      case ValidInstructionTypesEnum.MintTo:\n        let mintToInstruction: DecodedMintToInstruction;\n        if (instruction.programId.toString() !== TOKEN_2022_PROGRAM_ID.toString()) {\n          mintToInstruction = decodeMintToInstruction(instruction);\n        } else {\n          mintToInstruction = decodeMintToInstruction(instruction, TOKEN_2022_PROGRAM_ID);\n        }\n        const mintAddressForMint = mintToInstruction.keys.mint.pubkey.toString();\n        const tokenNameForMint = findTokenName(mintAddressForMint, instructionMetadata, _useTokenAddressTokenName);\n        let programIDForMint: string | undefined;\n        if (instruction.programId) {\n          programIDForMint = instruction.programId.toString();\n        }\n        const mintTo: MintTo = {\n          type: InstructionBuilderTypes.MintTo,\n          params: {\n            mintAddress: mintAddressForMint,\n            destinationAddress: mintToInstruction.keys.destination.pubkey.toString(),\n            authorityAddress: mintToInstruction.keys.authority.pubkey.toString(),\n            amount: mintToInstruction.data.amount.toString(),\n            tokenName: tokenNameForMint,\n            decimalPlaces: undefined,\n            programId: programIDForMint,\n          },\n        };\n        instructionData.push(mintTo);\n        break;\n      case ValidInstructionTypesEnum.Burn:\n        let burnInstruction: DecodedBurnInstruction;\n        if (instruction.programId.toString() !== TOKEN_2022_PROGRAM_ID.toString()) {\n          burnInstruction = decodeBurnInstruction(instruction);\n        } else {\n          burnInstruction = decodeBurnInstruction(instruction, TOKEN_2022_PROGRAM_ID);\n        }\n        const mintAddressForBurn = burnInstruction.keys.mint.pubkey.toString();\n        const tokenNameForBurn = findTokenName(mintAddressForBurn, instructionMetadata, _useTokenAddressTokenName);\n        let programIDForBurn: string | undefined;\n        if (instruction.programId) {\n          programIDForBurn = instruction.programId.toString();\n        }\n        const burn: Burn = {\n          type: InstructionBuilderTypes.Burn,\n          params: {\n            mintAddress: mintAddressForBurn,\n            accountAddress: burnInstruction.keys.account.pubkey.toString(),\n            authorityAddress: burnInstruction.keys.owner.pubkey.toString(),\n            amount: burnInstruction.data.amount.toString(),\n            tokenName: tokenNameForBurn,\n            decimalPlaces: undefined,\n            programId: programIDForBurn,\n          },\n        };\n        instructionData.push(burn);\n        break;\n      case ValidInstructionTypesEnum.PermissionlessThawIdempotent:\n        // Account order matches the fixed layout emitted by solInstructionFactory:\n        // [authority, mint, tokenAccount, flagAccount, tokenAccountOwner, mintConfig,\n        //  tokenProgram, systemProgram, gatingProgram, ...extraAccounts].\n        const thawExtraAccounts: ExtraAccountMeta[] = instruction.keys.slice(9).map((key) => ({\n          pubkey: key.pubkey.toString(),\n          isSigner: key.isSigner,\n          isWritable: key.isWritable,\n        }));\n        const permissionlessThaw: PermissionlessThawIdempotent = {\n          type: InstructionBuilderTypes.PermissionlessThawIdempotent,\n          params: {\n            authority: instruction.keys[0].pubkey.toString(),\n            mint: instruction.keys[1].pubkey.toString(),\n            tokenAccount: instruction.keys[2].pubkey.toString(),\n            flagAccount: instruction.keys[3].pubkey.toString(),\n            tokenAccountOwner: instruction.keys[4].pubkey.toString(),\n            mintConfig: instruction.keys[5].pubkey.toString(),\n            tokenProgram: instruction.keys[6].pubkey.toString(),\n            systemProgram: instruction.keys[7].pubkey.toString(),\n            gatingProgram: instruction.keys[8].pubkey.toString(),\n            extraAccounts: thawExtraAccounts,\n          },\n        };\n        instructionData.push(permissionlessThaw);\n        break;\n      default:\n        throw new NotSupported(\n          'Invalid transaction, instruction type not supported: ' + getInstructionType(instruction)\n        );\n    }\n  }\n  return instructionData;\n}\n\ntype StakingInstructions = {\n  depositSol?: DepositSolParams;\n  create?: CreateAccountParams;\n  initialize?: InitializeStakeParams;\n  delegate?: DelegateStakeParams;\n  hasAtaInit?: boolean;\n};\n\ntype JitoStakingInstructions = StakingInstructions & {\n  depositSol: NonNullable<StakingInstructions['depositSol']>;\n};\n\nfunction isJitoStakingInstructions(si: StakingInstructions): si is JitoStakingInstructions {\n  return si.depositSol !== undefined;\n}\n\ntype MarinadeStakingInstructions = StakingInstructions & {\n  create: NonNullable<StakingInstructions['create']>;\n  initialize: NonNullable<StakingInstructions['initialize']>;\n};\n\nfunction isMarinadeStakingInstructions(si: StakingInstructions): si is MarinadeStakingInstructions {\n  return si.create !== undefined && si.initialize !== undefined && si.delegate === undefined;\n}\n\ntype NativeStakingInstructions = StakingInstructions & {\n  create: NonNullable<StakingInstructions['create']>;\n  initialize: NonNullable<StakingInstructions['initialize']>;\n  delegate: NonNullable<StakingInstructions['delegate']>;\n};\n\nfunction isNativeStakingInstructions(si: StakingInstructions): si is NativeStakingInstructions {\n  return si.create !== undefined && si.initialize !== undefined && si.delegate !== undefined;\n}\n\nfunction getStakingTypeFromStakingInstructions(si: StakingInstructions): SolStakingTypeEnum {\n  const isJito = isJitoStakingInstructions(si);\n  const isMarinade = isMarinadeStakingInstructions(si);\n  const isNative = isNativeStakingInstructions(si);\n  assert([isJito, isMarinade, isNative].filter((x) => x).length === 1, 'StakingType is ambiguous');\n  if (isJito) return SolStakingTypeEnum.JITO;\n  if (isMarinade) return SolStakingTypeEnum.MARINADE;\n  if (isNative) return SolStakingTypeEnum.NATIVE;\n  assert(false, 'No StakingType found');\n}\n\n/**\n * Parses Solana instructions to create staking tx and delegate tx instructions params\n * Only supports Nonce, StakingActivate and Memo Solana instructions\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking activate tx\n */\nfunction parseStakingActivateInstructions(\n  instructions: TransactionInstruction[]\n): Array<Nonce | StakingActivate | Memo | AtaInit | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<Nonce | StakingActivate | Memo | AtaInit | SetComputeUnitLimit | SetPriorityFee> = [];\n  const stakingInstructions = {} as StakingInstructions;\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n\n      case ValidInstructionTypesEnum.Memo:\n        const memo: Memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };\n        instructionData.push(memo);\n        break;\n\n      case ValidInstructionTypesEnum.Create:\n        stakingInstructions.create = SystemInstruction.decodeCreateAccount(instruction);\n        break;\n\n      case ValidInstructionTypesEnum.StakingInitialize:\n        stakingInstructions.initialize = StakeInstruction.decodeInitialize(instruction);\n        break;\n\n      case ValidInstructionTypesEnum.StakingDelegate:\n        stakingInstructions.delegate = StakeInstruction.decodeDelegate(instruction);\n        break;\n\n      case ValidInstructionTypesEnum.DepositSol:\n        stakingInstructions.depositSol = decodeDepositSol(instruction);\n        break;\n\n      case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:\n        stakingInstructions.hasAtaInit = true;\n        instructionData.push({\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            mintAddress: instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString(),\n            ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),\n            ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),\n            payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),\n            tokenName: findTokenName(instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString()),\n          },\n        });\n        break;\n    }\n  }\n\n  validateStakingInstructions(stakingInstructions);\n  const stakingType = getStakingTypeFromStakingInstructions(stakingInstructions);\n\n  let stakingActivate: StakingActivate | undefined;\n\n  switch (stakingType) {\n    case SolStakingTypeEnum.JITO: {\n      assert(isJitoStakingInstructions(stakingInstructions));\n      const { depositSol, hasAtaInit } = stakingInstructions;\n      stakingActivate = {\n        type: InstructionBuilderTypes.StakingActivate,\n        params: {\n          stakingType,\n          fromAddress: depositSol.fundingAccount.toString(),\n          stakingAddress: depositSol.stakePool.toString(),\n          amount: depositSol.lamports.toString(),\n          validator: depositSol.stakePool.toString(),\n          extraParams: {\n            stakePoolData: {\n              managerFeeAccount: depositSol.managerFeeAccount.toString(),\n              poolMint: depositSol.poolMint.toString(),\n              reserveStake: depositSol.reserveStake.toString(),\n            },\n            createAssociatedTokenAccount: !!hasAtaInit,\n          },\n        },\n      };\n      break;\n    }\n\n    case SolStakingTypeEnum.MARINADE: {\n      assert(isMarinadeStakingInstructions(stakingInstructions));\n      const { create, initialize } = stakingInstructions;\n      stakingActivate = {\n        type: InstructionBuilderTypes.StakingActivate,\n        params: {\n          stakingType,\n          fromAddress: create.fromPubkey.toString(),\n          stakingAddress: initialize.stakePubkey.toString(),\n          amount: create.lamports.toString(),\n          validator: initialize.authorized.staker.toString(),\n        },\n      };\n      break;\n    }\n\n    case SolStakingTypeEnum.NATIVE: {\n      assert(isNativeStakingInstructions(stakingInstructions));\n      const { create, initialize, delegate } = stakingInstructions;\n      stakingActivate = {\n        type: InstructionBuilderTypes.StakingActivate,\n        params: {\n          stakingType,\n          fromAddress: create.fromPubkey.toString(),\n          stakingAddress: initialize.stakePubkey.toString(),\n          amount: create.lamports.toString(),\n          validator: delegate.votePubkey.toString(),\n        },\n      };\n      break;\n    }\n\n    default: {\n      const unreachable: never = stakingType;\n      throw new Error(`Unknown staking type ${unreachable}`);\n    }\n  }\n\n  instructionData.push(stakingActivate);\n\n  return instructionData;\n}\n/**\n * Parses Solana instructions to create delegate tx\n * Only supports Nonce, StakingDelegate\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking delegate tx\n */\nfunction parseStakingDelegateInstructions(\n  instructions: TransactionInstruction[]\n): Array<Nonce | StakingDelegate | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<Nonce | StakingDelegate | SetComputeUnitLimit | SetPriorityFee> = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n\n      case ValidInstructionTypesEnum.StakingDelegate:\n        const stakingDelegateParams = StakeInstruction.decodeDelegate(instruction);\n        const stakingDelegate: StakingDelegate = {\n          type: InstructionBuilderTypes.StakingDelegate,\n          params: {\n            fromAddress: stakingDelegateParams.authorizedPubkey.toString() || '',\n            stakingAddress: stakingDelegateParams.stakePubkey.toString() || '',\n            validator: stakingDelegateParams.votePubkey.toString() || '',\n          },\n        };\n        instructionData.push(stakingDelegate);\n        break;\n    }\n  }\n  return instructionData;\n}\n\nfunction validateStakingInstructions(stakingInstructions: StakingInstructions) {\n  if (stakingInstructions.delegate === undefined && stakingInstructions.depositSol !== undefined) {\n    return;\n  }\n\n  if (!stakingInstructions.create) {\n    throw new NotSupported('Invalid staking activate transaction, missing create stake account instruction');\n  }\n\n  if (!stakingInstructions.delegate && !stakingInstructions.initialize) {\n    throw new NotSupported(\n      'Invalid staking activate transaction, missing initialize stake account/delegate instruction'\n    );\n  }\n}\n\ntype UnstakingInstructions = {\n  allocate?: AllocateParams;\n  assign?: AssignParams;\n  split?: SplitStakeParams;\n  deactivate?: DeactivateStakeParams;\n  transfer?: DecodedTransferInstruction;\n  withdrawStake?: WithdrawStakeParams;\n};\n\ntype JitoUnstakingInstructions = UnstakingInstructions & {\n  withdrawStake: NonNullable<UnstakingInstructions['withdrawStake']>;\n};\n\nfunction isJitoUnstakingInstructions(ui: UnstakingInstructions): ui is JitoUnstakingInstructions {\n  return ui.withdrawStake !== undefined && ui.deactivate !== undefined;\n}\n\ntype MarinadeUnstakingInstructions = UnstakingInstructions & {\n  transfer: NonNullable<UnstakingInstructions['transfer']>;\n};\n\nfunction isMarinadeUnstakingInstructions(ui: UnstakingInstructions): ui is MarinadeUnstakingInstructions {\n  return ui.transfer !== undefined && ui.deactivate === undefined;\n}\n\ntype NativeUnstakingInstructions = UnstakingInstructions & {\n  deactivate: NonNullable<UnstakingInstructions['deactivate']>;\n  split: UnstakingInstructions['split'];\n};\n\nfunction isNativeUnstakingInstructions(ui: UnstakingInstructions): ui is NativeUnstakingInstructions {\n  return ui.withdrawStake === undefined && ui.deactivate !== undefined;\n}\n\nfunction getStakingTypeFromUnstakingInstructions(ui: UnstakingInstructions): SolStakingTypeEnum {\n  const isJito = isJitoUnstakingInstructions(ui);\n  const isMarinade = isMarinadeUnstakingInstructions(ui);\n  const isNative = isNativeUnstakingInstructions(ui);\n  assert([isJito, isMarinade, isNative].filter((x) => x).length === 1, 'StakingType is ambiguous');\n  if (isJito) return SolStakingTypeEnum.JITO;\n  if (isMarinade) return SolStakingTypeEnum.MARINADE;\n  if (isNative) return SolStakingTypeEnum.NATIVE;\n  assert(false, 'No StakingType found');\n}\n\n/**\n * Parses Solana instructions to create deactivate stake tx instructions params. Supports full stake\n * account deactivation and partial stake account deactivation.\n *\n * When partially deactivating a stake account this method expects the following instructions: Allocate,\n * to allocate a new staking account, Assign, to assign the newly created staking account to the\n * Stake Program, Split, to split the current stake account, and StakingDeactivate to deactivate the\n * newly created stake account.\n *\n * Supports Nonce, StakingDeactivate, Memo, Allocate, Assign, and Split Solana instructions.\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking deactivate tx\n */\nfunction parseStakingDeactivateInstructions(\n  instructions: TransactionInstruction[],\n  coinName?: string\n): Array<Nonce | StakingDeactivate | Memo | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<Nonce | StakingDeactivate | Memo | SetComputeUnitLimit | SetPriorityFee> = [];\n  const unstakingInstructions: UnstakingInstructions[] = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n\n      case ValidInstructionTypesEnum.Memo:\n        const memo: Memo = {\n          type: InstructionBuilderTypes.Memo,\n          params: { memo: instruction.data.toString() },\n        };\n        instructionData.push(memo);\n        break;\n\n      case ValidInstructionTypesEnum.Allocate:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].allocate === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].allocate =\n            SystemInstruction.decodeAllocate(instruction);\n        } else {\n          unstakingInstructions.push({\n            allocate: SystemInstruction.decodeAllocate(instruction),\n          });\n        }\n        break;\n\n      case ValidInstructionTypesEnum.Assign:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].assign === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].assign = SystemInstruction.decodeAssign(instruction);\n        } else {\n          unstakingInstructions.push({\n            assign: SystemInstruction.decodeAssign(instruction),\n          });\n        }\n        break;\n\n      case ValidInstructionTypesEnum.Split:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].split === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].split = StakeInstruction.decodeSplit(instruction);\n        } else {\n          unstakingInstructions.push({\n            split: StakeInstruction.decodeSplit(instruction),\n          });\n        }\n        break;\n\n      case ValidInstructionTypesEnum.StakingDeactivate:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].deactivate === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].deactivate =\n            StakeInstruction.decodeDeactivate(instruction);\n        } else {\n          unstakingInstructions.push({\n            deactivate: StakeInstruction.decodeDeactivate(instruction),\n          });\n        }\n        break;\n\n      case ValidInstructionTypesEnum.Transfer:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].transfer === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].transfer =\n            SystemInstruction.decodeTransfer(instruction);\n        } else {\n          unstakingInstructions.push({\n            transfer: SystemInstruction.decodeTransfer(instruction),\n          });\n        }\n        break;\n\n      case ValidInstructionTypesEnum.WithdrawStake:\n        if (\n          unstakingInstructions.length > 0 &&\n          unstakingInstructions[unstakingInstructions.length - 1].withdrawStake === undefined\n        ) {\n          unstakingInstructions[unstakingInstructions.length - 1].withdrawStake = decodeWithdrawStake(instruction);\n        } else {\n          unstakingInstructions.push({\n            withdrawStake: decodeWithdrawStake(instruction),\n          });\n        }\n        break;\n    }\n  }\n\n  for (const unstakingInstruction of unstakingInstructions) {\n    validateUnstakingInstructions(unstakingInstruction);\n    const stakingType = getStakingTypeFromUnstakingInstructions(unstakingInstruction);\n\n    let stakingDeactivate: StakingDeactivate | undefined;\n\n    switch (stakingType) {\n      case SolStakingTypeEnum.JITO: {\n        assert(isJitoUnstakingInstructions(unstakingInstruction));\n        const { withdrawStake } = unstakingInstruction;\n        stakingDeactivate = {\n          type: InstructionBuilderTypes.StakingDeactivate,\n          params: {\n            stakingType,\n            fromAddress: withdrawStake.destinationStakeAuthority.toString(),\n            stakingAddress: withdrawStake.stakePool.toString(),\n            amount: withdrawStake.poolTokens.toString(),\n            unstakingAddress: withdrawStake.destinationStake.toString(),\n            extraParams: {\n              stakePoolData: {\n                managerFeeAccount: withdrawStake.managerFeeAccount.toString(),\n                poolMint: withdrawStake.poolMint.toString(),\n                validatorListAccount: withdrawStake.validatorList.toString(),\n              },\n              validatorAddress: withdrawStake.validatorStake.toString(),\n              transferAuthorityAddress: withdrawStake.sourceTransferAuthority.toString(),\n            },\n          },\n        };\n        break;\n      }\n\n      case SolStakingTypeEnum.MARINADE: {\n        assert(isMarinadeUnstakingInstructions(unstakingInstruction));\n        const { transfer } = unstakingInstruction;\n\n        stakingDeactivate = {\n          type: InstructionBuilderTypes.StakingDeactivate,\n          params: {\n            stakingType,\n            fromAddress: '',\n            stakingAddress: '',\n            recipients: [\n              {\n                address: transfer.toPubkey.toString() || '',\n                amount: transfer.lamports.toString() || '',\n              },\n            ],\n          },\n        };\n        break;\n      }\n\n      case SolStakingTypeEnum.NATIVE: {\n        assert(isNativeUnstakingInstructions(unstakingInstruction));\n        const { deactivate, split } = unstakingInstruction;\n        stakingDeactivate = {\n          type: InstructionBuilderTypes.StakingDeactivate,\n          params: {\n            stakingType,\n            fromAddress: deactivate.authorizedPubkey.toString() || '',\n            stakingAddress: split?.stakePubkey.toString() || deactivate.stakePubkey.toString(),\n            amount: split?.lamports.toString(),\n            unstakingAddress: split?.splitStakePubkey.toString(),\n          },\n        };\n        break;\n      }\n\n      default: {\n        const unreachable: never = stakingType;\n        throw new Error(`Unknown staking type ${unreachable}`);\n      }\n    }\n\n    instructionData.push(stakingDeactivate);\n  }\n\n  return instructionData;\n}\n\nfunction validateUnstakingInstructions(unstakingInstructions: UnstakingInstructions) {\n  // Cases where exactly one field should be present\n  const unstakingInstructionsKeys: (keyof UnstakingInstructions)[] = [\n    'allocate',\n    'assign',\n    'split',\n    'deactivate',\n    'transfer',\n  ] as const;\n  if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'transfer'))) {\n    return;\n  }\n  if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'withdrawStake'))) {\n    return;\n  }\n  if (unstakingInstructionsKeys.every((k) => !!unstakingInstructions[k] === (k === 'deactivate'))) {\n    return;\n  }\n\n  // Cases where deactivate field must be present with another field\n  if (!unstakingInstructions.deactivate) {\n    throw new NotSupported('Invalid deactivate stake transaction, missing deactivate stake account instruction');\n  }\n\n  // This is a stake pool instruction, not a partial unstake\n  if (unstakingInstructions.withdrawStake) {\n    return;\n  }\n\n  if (!unstakingInstructions.allocate) {\n    throw new NotSupported(\n      'Invalid partial deactivate stake transaction, missing allocate unstake account instruction'\n    );\n  } else if (!unstakingInstructions.assign) {\n    throw new NotSupported('Invalid partial deactivate stake transaction, missing assign unstake account instruction');\n  } else if (!unstakingInstructions.split) {\n    throw new NotSupported('Invalid partial deactivate stake transaction, missing split stake account instruction');\n  } else if (\n    unstakingInstructions.allocate.accountPubkey.toString() !== unstakingInstructions.assign.accountPubkey.toString()\n  ) {\n    throw new NotSupported(\n      'Invalid partial deactivate stake transaction, must allocate and assign the same public key'\n    );\n  } else if (unstakingInstructions.allocate.space !== StakeProgram.space) {\n    throw new NotSupported(\n      `Invalid partial deactivate stake transaction, unstaking account must allocate ${StakeProgram.space} bytes`\n    );\n  } else if (unstakingInstructions.assign.programId.toString() !== StakeProgram.programId.toString()) {\n    throw new NotSupported(\n      'Invalid partial deactivate stake transaction, the unstake account must be assigned to the Stake Program'\n    );\n  } else if (\n    unstakingInstructions.allocate.accountPubkey.toString() !== unstakingInstructions.split.splitStakePubkey.toString()\n  ) {\n    throw new NotSupported('Invalid partial deactivate stake transaction, must allocate the unstaking account');\n  } else if (\n    unstakingInstructions.split.stakePubkey.toString() === unstakingInstructions.split.splitStakePubkey.toString()\n  ) {\n    throw new NotSupported(\n      'Invalid partial deactivate stake transaction, the unstaking account must be different from the Stake Account'\n    );\n  } else if (!unstakingInstructions.transfer) {\n    throw new NotSupported(\n      'Invalid partial deactivate stake transaction, missing funding of unstake address instruction'\n    );\n  }\n}\n\n/**\n * Parses Solana instructions to create staking  withdraw tx instructions params\n * Only supports Nonce, StakingWithdraw, and Memo Solana instructions\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking withdraw tx\n */\nfunction parseStakingWithdrawInstructions(\n  instructions: TransactionInstruction[]\n): Array<Nonce | StakingWithdraw | Memo | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<Nonce | StakingWithdraw | Memo | SetComputeUnitLimit | SetPriorityFee> = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n\n      case ValidInstructionTypesEnum.Memo:\n        const memo: Memo = {\n          type: InstructionBuilderTypes.Memo,\n          params: { memo: instruction.data.toString() },\n        };\n        instructionData.push(memo);\n        break;\n\n      case ValidInstructionTypesEnum.StakingWithdraw:\n        const withdrawInstruction = StakeInstruction.decodeWithdraw(instruction);\n        const stakingWithdraw: StakingWithdraw = {\n          type: InstructionBuilderTypes.StakingWithdraw,\n          params: {\n            fromAddress: withdrawInstruction.authorizedPubkey.toString(),\n            stakingAddress: withdrawInstruction.stakePubkey.toString(),\n            amount: withdrawInstruction.lamports.toString(),\n          },\n        };\n        instructionData.push(stakingWithdraw);\n        break;\n    }\n  }\n\n  return instructionData;\n}\n\n/**\n * Get the memo object from instructions if it exists\n *\n * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed\n * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction\n * @returns {Memo | undefined} - memo object or undefined\n */\nfunction getMemo(instructions: TransactionInstruction[], instructionIndexes: Record<string, number>): Memo | undefined {\n  const instructionsLength = Object.keys(instructionIndexes).length;\n  if (instructions.length === instructionsLength && instructions[instructionIndexes.Memo]) {\n    return {\n      type: InstructionBuilderTypes.Memo,\n      params: { memo: instructions[instructionIndexes.Memo].data.toString() },\n    };\n  }\n}\n\nconst ataInitInstructionKeysIndexes = {\n  PayerAddress: 0,\n  ATAAddress: 1,\n  OwnerAddress: 2,\n  MintAddress: 3,\n};\n\nconst closeAtaInstructionKeysIndexes = {\n  AccountAddress: 0,\n  DestinationAddress: 1,\n  AuthorityAddress: 2,\n};\n\n/**\n * Parses Solana instructions to initialize associated token account tx instructions params\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for Send tx\n */\nfunction parseAtaInitInstructions(\n  instructions: TransactionInstruction[],\n  instructionMetadata?: InstructionParams[],\n  _useTokenAddressTokenName?: boolean\n): Array<AtaInit | PermissionlessThawIdempotent | Memo | Nonce | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<\n    AtaInit | PermissionlessThawIdempotent | Memo | Nonce | SetComputeUnitLimit | SetPriorityFee\n  > = [];\n  let memo: Memo | undefined;\n\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.Memo:\n        memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };\n        break;\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n      case ValidInstructionTypesEnum.InitializeAssociatedTokenAccount:\n        const mintAddress = instruction.keys[ataInitInstructionKeysIndexes.MintAddress].pubkey.toString();\n        const tokenName = findTokenName(mintAddress, instructionMetadata, _useTokenAddressTokenName);\n        let programID: string | undefined;\n        if (instruction.programId) {\n          programID = instruction.programId.toString();\n        }\n        const ataInit: AtaInit = {\n          type: InstructionBuilderTypes.CreateAssociatedTokenAccount,\n          params: {\n            mintAddress,\n            ataAddress: instruction.keys[ataInitInstructionKeysIndexes.ATAAddress].pubkey.toString(),\n            ownerAddress: instruction.keys[ataInitInstructionKeysIndexes.OwnerAddress].pubkey.toString(),\n            payerAddress: instruction.keys[ataInitInstructionKeysIndexes.PayerAddress].pubkey.toString(),\n            tokenName,\n            programId: programID,\n          },\n        };\n        instructionData.push(ataInit);\n        break;\n      case ValidInstructionTypesEnum.PermissionlessThawIdempotent:\n        const thawExtraAccounts: ExtraAccountMeta[] = instruction.keys.slice(9).map((key) => ({\n          pubkey: key.pubkey.toString(),\n          isSigner: key.isSigner,\n          isWritable: key.isWritable,\n        }));\n        const permissionlessThaw: PermissionlessThawIdempotent = {\n          type: InstructionBuilderTypes.PermissionlessThawIdempotent,\n          params: {\n            authority: instruction.keys[0].pubkey.toString(),\n            mint: instruction.keys[1].pubkey.toString(),\n            tokenAccount: instruction.keys[2].pubkey.toString(),\n            flagAccount: instruction.keys[3].pubkey.toString(),\n            tokenAccountOwner: instruction.keys[4].pubkey.toString(),\n            mintConfig: instruction.keys[5].pubkey.toString(),\n            tokenProgram: instruction.keys[6].pubkey.toString(),\n            systemProgram: instruction.keys[7].pubkey.toString(),\n            gatingProgram: instruction.keys[8].pubkey.toString(),\n            extraAccounts: thawExtraAccounts,\n          },\n        };\n        instructionData.push(permissionlessThaw);\n        break;\n      case ValidInstructionTypesEnum.DepositSol:\n        // AtaInit is a part of spl-stake-pool's depositSol process\n        break;\n      default:\n        throw new NotSupported(\n          'Invalid transaction, instruction type not supported: ' + getInstructionType(instruction)\n        );\n    }\n  }\n  if (memo) {\n    instructionData.push(memo);\n  }\n  return instructionData;\n}\n\nconst ataCloseInstructionKeysIndexes = {\n  AccountAddress: 0,\n  DestinationAddress: 1,\n  AuthorityAddress: 2,\n};\n\nconst ataRecoverNestedInstructionKeysIndexes = {\n  NestedAccountAddress: 0,\n  NestedMintAddress: 1,\n  DestinationAccountAddress: 2,\n  OwnerAccountAddress: 3,\n  OwnerMintAddress: 4,\n  WalletAddress: 5,\n};\n\n/**\n * Parses Solana instructions to close associated token account tx instructions params\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for Send tx\n */\nfunction parseAtaCloseInstructions(\n  instructions: TransactionInstruction[]\n): Array<AtaClose | AtaRecoverNested | Nonce | SetComputeUnitLimit | SetPriorityFee> {\n  const instructionData: Array<AtaClose | AtaRecoverNested | Nonce | SetComputeUnitLimit | SetPriorityFee> = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n      case ValidInstructionTypesEnum.SetComputeUnitLimit:\n      case ValidInstructionTypesEnum.SetPriorityFee:\n        instructionData.push(parseComputeBudgetInstruction(instruction));\n        break;\n      case ValidInstructionTypesEnum.CloseAssociatedTokenAccount:\n        const ataClose: AtaClose = {\n          type: InstructionBuilderTypes.CloseAssociatedTokenAccount,\n          params: {\n            accountAddress: instruction.keys[ataCloseInstructionKeysIndexes.AccountAddress].pubkey.toString(),\n            destinationAddress: instruction.keys[ataCloseInstructionKeysIndexes.DestinationAddress].pubkey.toString(),\n            authorityAddress: instruction.keys[ataCloseInstructionKeysIndexes.AuthorityAddress].pubkey.toString(),\n            ...(instruction.programId.equals(TOKEN_2022_PROGRAM_ID)\n              ? { programId: instruction.programId.toString() }\n              : {}),\n          },\n        };\n        instructionData.push(ataClose);\n        break;\n      case ValidInstructionTypesEnum.RecoverNestedAssociatedTokenAccount:\n        const ataRecoverNested: AtaRecoverNested = {\n          type: InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount,\n          params: {\n            nestedAccountAddress:\n              instruction.keys[ataRecoverNestedInstructionKeysIndexes.NestedAccountAddress].pubkey.toString(),\n            nestedMintAddress:\n              instruction.keys[ataRecoverNestedInstructionKeysIndexes.NestedMintAddress].pubkey.toString(),\n            destinationAccountAddress:\n              instruction.keys[ataRecoverNestedInstructionKeysIndexes.DestinationAccountAddress].pubkey.toString(),\n            ownerAccountAddress:\n              instruction.keys[ataRecoverNestedInstructionKeysIndexes.OwnerAccountAddress].pubkey.toString(),\n            ownerMintAddress:\n              instruction.keys[ataRecoverNestedInstructionKeysIndexes.OwnerMintAddress].pubkey.toString(),\n            walletAddress: instruction.keys[ataRecoverNestedInstructionKeysIndexes.WalletAddress].pubkey.toString(),\n          },\n        };\n        instructionData.push(ataRecoverNested);\n        break;\n      default:\n        throw new NotSupported(\n          'Invalid transaction, instruction type not supported: ' + getInstructionType(instruction)\n        );\n    }\n  }\n  return instructionData;\n}\n\n/**\n * Parses Solana instructions to authorized staking account params\n * Only supports Nonce, Authorize instructions\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking authorize tx\n */\nfunction parseStakingAuthorizeInstructions(\n  instructions: TransactionInstruction[]\n): Array<Nonce | StakingAuthorize | Memo> {\n  const instructionData: Array<Nonce | StakingAuthorize | Memo> = [];\n  for (const instruction of instructions) {\n    const type = getInstructionType(instruction);\n    switch (type) {\n      case ValidInstructionTypesEnum.AdvanceNonceAccount:\n        const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instruction);\n        const nonce: Nonce = {\n          type: InstructionBuilderTypes.NonceAdvance,\n          params: {\n            walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n            authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n          },\n        };\n        instructionData.push(nonce);\n        break;\n\n      case ValidInstructionTypesEnum.Memo:\n        const memo: Memo = { type: InstructionBuilderTypes.Memo, params: { memo: instruction.data.toString() } };\n        instructionData.push(memo);\n        break;\n\n      case ValidInstructionTypesEnum.Authorize:\n        const authorize = StakeInstruction.decodeAuthorize(instruction);\n        instructionData.push({\n          type: InstructionBuilderTypes.StakingAuthorize,\n          params: {\n            stakingAddress: authorize.stakePubkey.toString(),\n            oldAuthorizeAddress: authorize.authorizedPubkey.toString(),\n            newAuthorizeAddress: authorize.newAuthorizedPubkey.toString(),\n            newWithdrawAddress: authorize.custodianPubkey?.toString() || '',\n          },\n        });\n        break;\n    }\n  }\n\n  return instructionData;\n}\n\n/**\n * Parses Solana instructions to authorized staking account params\n * Only supports Nonce, Authorize instructions\n *\n * @param {TransactionInstruction[]} instructions - an array of supported Solana instructions\n * @returns {InstructionParams[]} An array containing instruction params for staking authorize tx\n */\nfunction parseStakingAuthorizeRawInstructions(instructions: TransactionInstruction[]): Array<Nonce | StakingAuthorize> {\n  const instructionData: Array<Nonce | StakingAuthorize> = [];\n  assert(instructions.length === 2, 'Invalid number of instructions');\n  const advanceNonceInstruction = SystemInstruction.decodeNonceAdvance(instructions[0]);\n  const nonce: Nonce = {\n    type: InstructionBuilderTypes.NonceAdvance,\n    params: {\n      walletNonceAddress: advanceNonceInstruction.noncePubkey.toString(),\n      authWalletAddress: advanceNonceInstruction.authorizedPubkey.toString(),\n    },\n  };\n  instructionData.push(nonce);\n  const authorize = instructions[1];\n  assert(authorize.keys.length === 5, 'Invalid number of keys in authorize instruction');\n  instructionData.push({\n    type: InstructionBuilderTypes.StakingAuthorize,\n    params: {\n      stakingAddress: authorize.keys[0].pubkey.toString(),\n      oldAuthorizeAddress: authorize.keys[2].pubkey.toString(),\n      newAuthorizeAddress: authorize.keys[3].pubkey.toString(),\n      custodianAddress: authorize.keys[4].pubkey.toString(),\n    },\n  });\n  return instructionData;\n}\n\n/**\n * Returns true if the instruction type is a confidential transfer instruction\n * (Token-2022 CT extension or zk-elgamal-proof program).\n */\nfunction isConfidentialTransferInstruction(type: InstructionBuilderTypes): boolean {\n  switch (type) {\n    case InstructionBuilderTypes.ConfigureConfidentialTransferAccount:\n    case InstructionBuilderTypes.ApplyPendingBalance:\n    case InstructionBuilderTypes.ConfidentialDeposit:\n    case InstructionBuilderTypes.ConfidentialWithdraw:\n    case InstructionBuilderTypes.ConfidentialTransfer:\n    case InstructionBuilderTypes.VerifyPubkeyValidity:\n    case InstructionBuilderTypes.VerifyEqualityProof:\n    case InstructionBuilderTypes.VerifyValidityProof:\n    case InstructionBuilderTypes.VerifyRangeProof:\n    case InstructionBuilderTypes.ReallocateConfidentialTransferAccount:\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Parses Solana instructions to custom instruction params\n *\n * @param {TransactionInstruction[]} instructions - containing custom solana instructions\n * @param {InstructionParams[]} instructionMetadata - the instruction metadata for the transaction\n * @returns {InstructionParams[]} An array containing instruction params for custom instructions\n */\nfunction parseCustomInstructions(\n  instructions: TransactionInstruction[],\n  instructionMetadata?: InstructionParams[]\n): CustomInstruction[] {\n  const instructionData: CustomInstruction[] = [];\n\n  for (let i = 0; i < instructions.length; i++) {\n    const instruction = instructions[i];\n\n    // Check if we have metadata for this instruction position\n    if (\n      instructionMetadata &&\n      instructionMetadata[i] &&\n      instructionMetadata[i].type === InstructionBuilderTypes.CustomInstruction\n    ) {\n      instructionData.push(instructionMetadata[i] as CustomInstruction);\n    } else {\n      // Convert the raw instruction to CustomInstruction format\n      const customInstruction: CustomInstruction = {\n        type: InstructionBuilderTypes.CustomInstruction,\n        params: {\n          programId: instruction.programId.toString(),\n          keys: instruction.keys.map((key) => ({\n            pubkey: key.pubkey.toString(),\n            isSigner: key.isSigner,\n            isWritable: key.isWritable,\n          })),\n          data: instruction.data.toString('base64'),\n        },\n      };\n      instructionData.push(customInstruction);\n    }\n  }\n\n  return instructionData;\n}\n\n/**\n * Parses Solana instructions to confidential transfer instruction params.\n *\n * Iterates raw instructions in order, checking metadata at each position:\n * - CT instruction metadata is preserved as-is (CT instructions cannot be\n *   decoded by @solana/spl-token or @solana/web3.js).\n * - CustomInstruction metadata is preserved as-is.\n * - All other instructions fall back to CustomInstruction format with raw\n *   programId/keys/data.\n *\n * This single-pass approach preserves original instruction order so that\n * round-trip reconstruction is faithful.\n *\n * @param {TransactionInstruction[]} instructions - containing CT solana instructions\n * @param {InstructionParams[]} instructionMetadata - the instruction metadata for the transaction\n * @returns {InstructionParams[]} An array containing instruction params in original order\n */\nfunction parseConfidentialTransferInstructions(\n  instructions: TransactionInstruction[],\n  instructionMetadata?: InstructionParams[]\n): InstructionParams[] {\n  const instructionData: InstructionParams[] = [];\n\n  for (let i = 0; i < instructions.length; i++) {\n    const instruction = instructions[i];\n\n    // Check if we have metadata for this instruction position\n    if (instructionMetadata && instructionMetadata[i]) {\n      const metaType = instructionMetadata[i].type;\n      // Preserve confidential transfer, custom, and ATA-init metadata as-is\n      // (CT enablement txs carry CreateATA + ConfigureAccount + proofs).\n      if (\n        isConfidentialTransferInstruction(metaType) ||\n        metaType === InstructionBuilderTypes.CustomInstruction ||\n        metaType === InstructionBuilderTypes.CreateAssociatedTokenAccount\n      ) {\n        instructionData.push(instructionMetadata[i]);\n        continue;\n      }\n    }\n\n    // Convert the raw instruction to CustomInstruction format\n    const customInstruction: CustomInstruction = {\n      type: InstructionBuilderTypes.CustomInstruction,\n      params: {\n        programId: instruction.programId.toString(),\n        keys: instruction.keys.map((key) => ({\n          pubkey: key.pubkey.toString(),\n          isSigner: key.isSigner,\n          isWritable: key.isWritable,\n        })),\n        data: instruction.data.toString('base64'),\n      },\n    };\n    instructionData.push(customInstruction);\n  }\n\n  return instructionData;\n}\n\nexport function findTokenName(\n  mintAddress: string,\n  instructionMetadata?: InstructionParams[],\n  _useTokenAddressTokenName?: boolean\n): string {\n  let token: string | undefined;\n\n  coins.forEach((value, key) => {\n    if (value instanceof SolCoin && value.tokenAddress === mintAddress) {\n      token = value.name;\n    }\n  });\n\n  if (!token && instructionMetadata) {\n    instructionMetadata.forEach((instruction) => {\n      if (\n        instruction.type === InstructionBuilderTypes.CreateAssociatedTokenAccount &&\n        instruction.params.mintAddress === mintAddress\n      ) {\n        token = instruction.params.tokenName;\n      } else if (\n        instruction.type === InstructionBuilderTypes.TokenTransfer &&\n        instruction.params.tokenAddress === mintAddress\n      ) {\n        token = instruction.params.tokenName;\n      }\n    });\n  }\n\n  if (!token && _useTokenAddressTokenName) {\n    token = mintAddress;\n  }\n\n  assert(token);\n\n  return token;\n}\n\nexport function findTransferHookAccounts(\n  fromAddress: string,\n  toAddress: string,\n  tokenAddress: string,\n  instructionMetadata?: InstructionParams[]\n): ExtraAccountMeta[] | undefined {\n  let transferHookAccounts: ExtraAccountMeta[] | undefined;\n\n  instructionMetadata?.forEach((instruction) => {\n    if (\n      instruction.type === InstructionBuilderTypes.TokenTransfer &&\n      instruction.params.tokenAddress === tokenAddress &&\n      instruction.params.fromAddress === fromAddress &&\n      instruction.params.toAddress === toAddress\n    ) {\n      transferHookAccounts = instruction.params.transferHookAccounts;\n    }\n  });\n\n  return transferHookAccounts;\n}\n"]}