@bitgo-beta/sdk-coin-sol 7.6.4-beta.78 → 7.6.4-beta.781

package/dist/esm/lib/solInstructionFactory.js

@@ -0,0 +1,1113 @@
+import { SolStakingTypeEnum } from '@bitgo/public-types';
+import { SolCoin } from '@bitgo-beta/statics';
+import { createAssociatedTokenAccountIdempotentInstruction, createCloseAccountInstruction, createMintToInstruction, createBurnInstruction, createRecoverNestedInstruction, createTransferCheckedInstruction, createTransferCheckedWithFeeInstruction, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID, createApproveInstruction, createReallocateInstruction, ExtensionType, } from '@solana/spl-token';
+import { struct, u8, s8, blob } from '@solana/buffer-layout';
+import { Authorized, Lockup, PublicKey, StakeAuthorizationLayout, StakeProgram, SystemProgram, Transaction, TransactionInstruction, ComputeBudgetProgram, } from '@solana/web3.js';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import { INSTRUCTIONS_SYSVAR_ADDRESS, InstructionBuilderTypes, MEMO_PROGRAM_PK, THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR, TOKEN_ACL_PROGRAM_ID, ZK_ELGAMAL_PROOF_PROGRAM_ID, CT_EXT_DISCRIMINATOR, } from './constants';
+import { computeTransferFee, getSolTokenFromTokenName, isValidBase64, isValidHex } from './utils';
+import { depositSolInstructions, withdrawStakeInstructions } from './jitoStakePoolOperations';
+/**
+ * Construct Solana instructions from instructions params
+ *
+ * @param {InstructionParams} instructionToBuild - the data containing the instruction params
+ * @returns {TransactionInstruction[]} An array containing supported Solana instructions
+ */
+export function solInstructionFactory(instructionToBuild, zkProofProgramId) {
+    switch (instructionToBuild.type) {
+        case InstructionBuilderTypes.NonceAdvance:
+            return advanceNonceInstruction(instructionToBuild);
+        case InstructionBuilderTypes.Memo:
+            return memoInstruction(instructionToBuild);
+        case InstructionBuilderTypes.Transfer:
+            return transferInstruction(instructionToBuild);
+        case InstructionBuilderTypes.TokenTransfer:
+            return tokenTransferInstruction(instructionToBuild);
+        case InstructionBuilderTypes.Approve:
+            return approveInstruction(instructionToBuild);
+        case InstructionBuilderTypes.CreateNonceAccount:
+            return createNonceAccountInstruction(instructionToBuild);
+        case InstructionBuilderTypes.StakingActivate:
+            return stakingInitializeInstruction(instructionToBuild);
+        case InstructionBuilderTypes.StakingDeactivate:
+            return stakingDeactivateInstruction(instructionToBuild);
+        case InstructionBuilderTypes.StakingWithdraw:
+            return stakingWithdrawInstruction(instructionToBuild);
+        case InstructionBuilderTypes.CreateAssociatedTokenAccount:
+            return createATAInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ReallocateConfidentialTransferAccount:
+            return reallocateConfidentialTransferAccountInstruction(instructionToBuild);
+        case InstructionBuilderTypes.CloseAssociatedTokenAccount:
+            return closeATAInstruction(instructionToBuild);
+        case InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount:
+            return recoverNestedATAInstruction(instructionToBuild);
+        case InstructionBuilderTypes.StakingAuthorize:
+            return stakingAuthorizeInstruction(instructionToBuild);
+        case InstructionBuilderTypes.StakingDelegate:
+            return stakingDelegateInstruction(instructionToBuild);
+        case InstructionBuilderTypes.SetComputeUnitLimit:
+            return setComputeUnitLimitInstruction(instructionToBuild);
+        case InstructionBuilderTypes.SetPriorityFee:
+            return fetchPriorityFeeInstruction(instructionToBuild);
+        case InstructionBuilderTypes.MintTo:
+            return mintToInstruction(instructionToBuild);
+        case InstructionBuilderTypes.Burn:
+            return burnInstruction(instructionToBuild);
+        case InstructionBuilderTypes.CustomInstruction:
+            return customInstruction(instructionToBuild);
+        case InstructionBuilderTypes.PermissionlessThawIdempotent:
+            return permissionlessThawIdempotentInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ConfigureConfidentialTransferAccount:
+            return configureConfidentialTransferAccountInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ApplyPendingBalance:
+            return applyPendingBalanceInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ConfidentialDeposit:
+            return confidentialDepositInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ConfidentialWithdraw:
+            return confidentialWithdrawInstruction(instructionToBuild);
+        case InstructionBuilderTypes.ConfidentialTransfer:
+            return confidentialTransferInstruction(instructionToBuild);
+        case InstructionBuilderTypes.VerifyPubkeyValidity:
+            return verifyPubkeyValidityInstruction(instructionToBuild, zkProofProgramId);
+        case InstructionBuilderTypes.VerifyEqualityProof:
+            return verifyEqualityProofInstruction(instructionToBuild, zkProofProgramId);
+        case InstructionBuilderTypes.VerifyValidityProof:
+            return verifyValidityProofInstruction(instructionToBuild, zkProofProgramId);
+        case InstructionBuilderTypes.VerifyRangeProof:
+            return verifyRangeProofInstruction(instructionToBuild, zkProofProgramId);
+        default:
+            throw new Error(`Invalid instruction type or not supported`);
+    }
+}
+/**
+ * Construct Advance Nonce Solana instructions
+ *
+ * @param {Nonce} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction
+ */
+function advanceNonceInstruction(data) {
+    const { params: { authWalletAddress, walletNonceAddress }, } = data;
+    assert(authWalletAddress, 'Missing authWalletAddress param');
+    assert(walletNonceAddress, 'Missing walletNonceAddress param');
+    const nonceInstruction = SystemProgram.nonceAdvance({
+        noncePubkey: new PublicKey(walletNonceAddress),
+        authorizedPubkey: new PublicKey(authWalletAddress),
+    });
+    return [nonceInstruction];
+}
+function setComputeUnitLimitInstruction(instructionToBuild) {
+    const setComputeUnitLimit = ComputeBudgetProgram.setComputeUnitLimit({
+        units: instructionToBuild.params.units,
+    });
+    return [setComputeUnitLimit];
+}
+function fetchPriorityFeeInstruction(instructionToBuild) {
+    const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: instructionToBuild.params.fee,
+    });
+    return [addPriorityFee];
+}
+/**
+ * Construct Memo Solana instructions
+ *
+ * @param {Memo} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Memo Solana instruction
+ */
+function memoInstruction(data) {
+    const { params: { memo }, } = data;
+    assert(memo, 'Missing memo param');
+    const memoInstruction = new TransactionInstruction({
+        keys: [],
+        programId: new PublicKey(MEMO_PROGRAM_PK),
+        data: Buffer.from(memo),
+    });
+    return [memoInstruction];
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function transferInstruction(data) {
+    const { params: { fromAddress, toAddress, amount }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    assert(toAddress, 'Missing toAddress param');
+    assert(amount, 'Missing toAddress param');
+    const transferInstruction = SystemProgram.transfer({
+        fromPubkey: new PublicKey(fromAddress),
+        toPubkey: new PublicKey(toAddress),
+        lamports: parseInt(amount, 10),
+    });
+    return [transferInstruction];
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function tokenTransferInstruction(data) {
+    const { params: { fromAddress, toAddress, amount, tokenName, sourceAddress }, } = data;
+    assert(fromAddress, 'Missing fromAddress (owner) param');
+    assert(toAddress, 'Missing toAddress param');
+    assert(amount, 'Missing amount param');
+    assert(tokenName, 'Missing token name');
+    assert(sourceAddress, 'Missing ata address');
+    const token = getSolTokenFromTokenName(data.params.tokenName);
+    let tokenAddress;
+    let programId;
+    let decimalPlaces;
+    if (data.params.tokenAddress && data.params.decimalPlaces != null) {
+        tokenAddress = data.params.tokenAddress;
+        decimalPlaces = data.params.decimalPlaces;
+        programId = data.params.programId;
+    }
+    else if (token) {
+        assert(token instanceof SolCoin);
+        tokenAddress = token.tokenAddress;
+        decimalPlaces = token.decimalPlaces;
+        programId = token.programId;
+    }
+    else {
+        throw new Error('Invalid token name, got:' + data.params.tokenName);
+    }
+    let transferInstruction;
+    const instructions = [];
+    if (programId === TOKEN_2022_PROGRAM_ID.toString()) {
+        // Use transferCheckedWithFee when the token has a TransferFee extension (or an explicit fee is
+        // supplied). The instruction fails on-chain if the expected fee != live config, protecting the
+        // customer from a mid-flight fee change. PRD 3.6.
+        const feeConfig = token instanceof SolCoin ? token.tokenExtensions?.transferFee : undefined;
+        const fee = data.params.fee ??
+            (feeConfig ? computeTransferFee(amount, feeConfig.transferFeeBasisPoints, feeConfig.maximumFee) : undefined);
+        if (fee !== undefined) {
+            transferInstruction = createTransferCheckedWithFeeInstruction(new PublicKey(sourceAddress), new PublicKey(tokenAddress), new PublicKey(toAddress), new PublicKey(fromAddress), BigInt(amount), decimalPlaces, BigInt(fee), [], TOKEN_2022_PROGRAM_ID);
+        }
+        else {
+            transferInstruction = createTransferCheckedInstruction(new PublicKey(sourceAddress), new PublicKey(tokenAddress), new PublicKey(toAddress), new PublicKey(fromAddress), BigInt(amount), decimalPlaces, [], TOKEN_2022_PROGRAM_ID);
+        }
+        // Append any resolved Transfer Hook extra accounts. These are resolved live by
+        // the caller (offline builders never fetch) and supplied in the required order.
+        if (data.params.transferHookAccounts?.length) {
+            addTransferHookAccounts(transferInstruction, data.params.transferHookAccounts);
+        }
+    }
+    else {
+        transferInstruction = createTransferCheckedInstruction(new PublicKey(sourceAddress), new PublicKey(tokenAddress), new PublicKey(toAddress), new PublicKey(fromAddress), BigInt(amount), decimalPlaces);
+    }
+    instructions.push(transferInstruction);
+    return instructions;
+}
+/**
+ * Construct Transfer Solana instructions
+ *
+ * @param {Transfer} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction
+ */
+function approveInstruction(data) {
+    const { params: { accountAddress, delegateAddress, ownerAddress, amount, programId }, } = data;
+    assert(accountAddress, 'Missing fromAddress (owner) param');
+    assert(delegateAddress, 'Missing toAddress param');
+    assert(ownerAddress, 'Missing ownerAddress param');
+    assert(programId, 'Missing programId param');
+    assert(amount, 'Missing amount param');
+    return [
+        createApproveInstruction(new PublicKey(accountAddress), new PublicKey(delegateAddress), new PublicKey(ownerAddress), BigInt(amount), undefined, programId === undefined ? undefined : new PublicKey(programId)),
+    ];
+}
+/**
+ * Construct Create and Initialize Nonce Solana instructions
+ *
+ * @param {WalletInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction
+ */
+function createNonceAccountInstruction(data) {
+    const { params: { fromAddress, nonceAddress, authAddress, amount }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    assert(nonceAddress, 'Missing nonceAddress param');
+    assert(authAddress, 'Missing authAddress param');
+    assert(amount, 'Missing amount param');
+    const nonceAccountInstruction = SystemProgram.createNonceAccount({
+        fromPubkey: new PublicKey(fromAddress),
+        noncePubkey: new PublicKey(nonceAddress),
+        authorizedPubkey: new PublicKey(authAddress),
+        lamports: new BigNumber(amount).toNumber(),
+    });
+    return nonceAccountInstruction.instructions;
+}
+/**
+ * Construct Create Staking Account and Delegate Solana instructions
+ *
+ * @param {StakingActivate} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Create Staking Account and Delegate Solana instructions
+ */
+function stakingInitializeInstruction(data) {
+    const { params: { fromAddress, stakingAddress, amount, validator, stakingType, extraParams }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    assert(stakingAddress, 'Missing stakingAddress param');
+    assert(amount, 'Missing amount param');
+    assert(validator, 'Missing validator param');
+    const fromPubkey = new PublicKey(fromAddress);
+    const stakePubkey = new PublicKey(stakingAddress);
+    const validatorPubkey = new PublicKey(validator);
+    const tx = new Transaction();
+    switch (stakingType) {
+        case SolStakingTypeEnum.JITO: {
+            assert(extraParams !== undefined, 'Missing extraParams param');
+            const instructions = depositSolInstructions({
+                stakePoolAddress: stakePubkey,
+                from: fromPubkey,
+                lamports: BigInt(amount),
+            }, extraParams.stakePoolData, !!extraParams.createAssociatedTokenAccount);
+            tx.add(...instructions);
+            break;
+        }
+        case SolStakingTypeEnum.MARINADE: {
+            const walletInitStaking = StakeProgram.createAccount({
+                fromPubkey,
+                stakePubkey,
+                authorized: new Authorized(validatorPubkey, fromPubkey), // staker and withdrawer
+                lockup: new Lockup(0, 0, fromPubkey), // No minimum epoch to withdraw
+                lamports: new BigNumber(amount).toNumber(),
+            });
+            tx.add(walletInitStaking);
+            break;
+        }
+        case SolStakingTypeEnum.NATIVE: {
+            const walletInitStaking = StakeProgram.createAccount({
+                fromPubkey,
+                stakePubkey,
+                authorized: new Authorized(fromPubkey, fromPubkey), // staker and withdrawer
+                lockup: new Lockup(0, 0, fromPubkey), // No minimum epoch to withdraw
+                lamports: new BigNumber(amount).toNumber(),
+            });
+            tx.add(walletInitStaking);
+            const delegateStaking = StakeProgram.delegate({
+                stakePubkey: new PublicKey(stakingAddress),
+                authorizedPubkey: new PublicKey(fromAddress),
+                votePubkey: new PublicKey(validator),
+            });
+            tx.add(delegateStaking);
+            break;
+        }
+        default: {
+            const unreachable = stakingType;
+            throw new Error(`Unknown staking type ${unreachable}`);
+        }
+    }
+    return tx.instructions;
+}
+/**
+ * Construct staking deactivate Solana instructions
+ *
+ * @param {StakingDeactivate} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing staking deactivate instruction
+ */
+function stakingDeactivateInstruction(data) {
+    const { params: { fromAddress, stakingAddress, amount, unstakingAddress, recipients, stakingType, extraParams }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    switch (stakingType) {
+        case SolStakingTypeEnum.JITO: {
+            assert(stakingAddress, 'Missing stakingAddress param');
+            assert(unstakingAddress, 'Missing unstakingAddress param');
+            assert(amount, 'Missing amount param');
+            assert(extraParams, 'Missing extraParams param');
+            const tx = new Transaction();
+            tx.add(...withdrawStakeInstructions({
+                stakePoolAddress: new PublicKey(stakingAddress),
+                tokenOwner: new PublicKey(fromAddress),
+                destinationStakeAccount: new PublicKey(unstakingAddress),
+                validatorAddress: new PublicKey(extraParams.validatorAddress),
+                transferAuthority: new PublicKey(extraParams.transferAuthorityAddress),
+                poolAmount: amount,
+            }, extraParams.stakePoolData));
+            return tx.instructions;
+        }
+        case SolStakingTypeEnum.MARINADE: {
+            assert(recipients, 'Missing recipients param');
+            const tx = new Transaction();
+            const toPubkeyAddress = new PublicKey(recipients[0].address || '');
+            const transferInstruction = SystemProgram.transfer({
+                fromPubkey: new PublicKey(fromAddress),
+                toPubkey: toPubkeyAddress,
+                lamports: parseInt(recipients[0].amount, 10),
+            });
+            tx.add(transferInstruction);
+            return tx.instructions;
+        }
+        case SolStakingTypeEnum.NATIVE: {
+            assert(stakingAddress, 'Missing stakingAddress param');
+            if (data.params.amount && data.params.unstakingAddress) {
+                const tx = new Transaction();
+                const unstakingAddress = new PublicKey(data.params.unstakingAddress);
+                const allocateAccount = SystemProgram.allocate({
+                    accountPubkey: unstakingAddress,
+                    space: StakeProgram.space,
+                });
+                tx.add(allocateAccount);
+                const assignAccount = SystemProgram.assign({
+                    accountPubkey: unstakingAddress,
+                    programId: StakeProgram.programId,
+                });
+                tx.add(assignAccount);
+                const splitStake = StakeProgram.split({
+                    stakePubkey: new PublicKey(stakingAddress),
+                    authorizedPubkey: new PublicKey(fromAddress),
+                    splitStakePubkey: unstakingAddress,
+                    lamports: new BigNumber(data.params.amount).toNumber(),
+                }, 0);
+                tx.add(splitStake.instructions[1]);
+                const deactivateStaking = StakeProgram.deactivate({
+                    stakePubkey: unstakingAddress,
+                    authorizedPubkey: new PublicKey(fromAddress),
+                });
+                tx.add(deactivateStaking);
+                return tx.instructions;
+            }
+            else {
+                const deactivateStaking = StakeProgram.deactivate({
+                    stakePubkey: new PublicKey(stakingAddress),
+                    authorizedPubkey: new PublicKey(fromAddress),
+                });
+                return deactivateStaking.instructions;
+            }
+        }
+        default: {
+            const unreachable = stakingType;
+            throw new Error(`Unknown staking type ${unreachable}`);
+        }
+    }
+}
+/**
+ * Construct Staking Withdraw Solana instructions
+ *
+ * @param {StakingWithdraw} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Staking Withdraw  Solana instructions
+ */
+function stakingWithdrawInstruction(data) {
+    const { params: { fromAddress, stakingAddress, amount }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    assert(stakingAddress, 'Missing stakingAddress param');
+    assert(amount, 'Missing amount param');
+    const withdrawStaking = StakeProgram.withdraw({
+        stakePubkey: new PublicKey(stakingAddress),
+        authorizedPubkey: new PublicKey(fromAddress),
+        toPubkey: new PublicKey(fromAddress),
+        lamports: new BigNumber(amount).toNumber(),
+    });
+    return withdrawStaking.instructions;
+}
+/**
+ * Construct an idempotent Create Associated Token Account instruction.
+ *
+ * Uses createAssociatedTokenAccountIdempotentInstruction so the instruction is a
+ * no-op when the ATA already exists (discriminator byte = 1), instead of failing
+ * like the legacy createAssociatedTokenAccountInstruction (empty data).
+ *
+ * @param {AtaInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing the Create ATA instruction
+ */
+function createATAInstruction(data) {
+    const { params: { mintAddress, ataAddress, ownerAddress, payerAddress, programId }, } = data;
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(ataAddress, 'Missing ataAddress param');
+    assert(ownerAddress, 'Missing ownerAddress param');
+    assert(payerAddress, 'Missing payerAddress param');
+    let associatedTokenAccountInstruction;
+    if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {
+        associatedTokenAccountInstruction = createAssociatedTokenAccountIdempotentInstruction(new PublicKey(payerAddress), new PublicKey(ataAddress), new PublicKey(ownerAddress), new PublicKey(mintAddress), TOKEN_2022_PROGRAM_ID);
+    }
+    else {
+        associatedTokenAccountInstruction = createAssociatedTokenAccountIdempotentInstruction(new PublicKey(payerAddress), new PublicKey(ataAddress), new PublicKey(ownerAddress), new PublicKey(mintAddress));
+    }
+    return [associatedTokenAccountInstruction];
+}
+/**
+ * Construct a Token-2022 Reallocate instruction that adds the ConfidentialTransferAccount
+ * extension. ConfigureAccount fails on-chain unless the account already holds the extension,
+ * and an ATA is created without it — so CT enablement must run this before ConfigureAccount.
+ *
+ * @param {ReallocateConfidentialTransferAccount} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} the Reallocate instruction
+ */
+function reallocateConfidentialTransferAccountInstruction(data) {
+    const { params: { tokenAddress, payerAddress, ownerAddress, programId }, } = data;
+    assert(tokenAddress, 'Missing tokenAddress param');
+    assert(payerAddress, 'Missing payerAddress param');
+    assert(ownerAddress, 'Missing ownerAddress param');
+    assert(programId && programId === TOKEN_2022_PROGRAM_ID.toString(), 'Reallocate requires the Token-2022 program');
+    return [
+        createReallocateInstruction(new PublicKey(tokenAddress), new PublicKey(payerAddress), [ExtensionType.ConfidentialTransferAccount], new PublicKey(ownerAddress), [], TOKEN_2022_PROGRAM_ID),
+    ];
+}
+/**
+ * Construct Close ATA Solana instructions
+ *
+ * @param {WalletInit} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Close ATA Solana instruction
+ */
+function closeATAInstruction(data) {
+    const { params: { accountAddress, destinationAddress, authorityAddress, programId }, } = data;
+    assert(accountAddress, 'Missing accountAddress param');
+    assert(destinationAddress, 'Missing destinationAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    const tokenProgramId = programId ? new PublicKey(programId) : TOKEN_PROGRAM_ID;
+    const closeAssociatedTokenAccountInstruction = createCloseAccountInstruction(new PublicKey(accountAddress), new PublicKey(destinationAddress), new PublicKey(authorityAddress), [], tokenProgramId);
+    return [closeAssociatedTokenAccountInstruction];
+}
+/**
+ * Construct RecoverNested ATA Solana instruction
+ *
+ * Recovers tokens from a nested ATA (an ATA whose owner is another ATA rather than a wallet address).
+ * This uses the Associated Token Account program's RecoverNested instruction, which allows the root
+ * wallet owner to sign and recover tokens without needing the intermediate ATA to sign.
+ *
+ * @param {AtaRecoverNested} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing the RecoverNested instruction
+ */
+function recoverNestedATAInstruction(data) {
+    const { params: { nestedAccountAddress, nestedMintAddress, destinationAccountAddress, ownerAccountAddress, ownerMintAddress, walletAddress, }, } = data;
+    assert(nestedAccountAddress, 'Missing nestedAccountAddress param');
+    assert(nestedMintAddress, 'Missing nestedMintAddress param');
+    assert(destinationAccountAddress, 'Missing destinationAccountAddress param');
+    assert(ownerAccountAddress, 'Missing ownerAccountAddress param');
+    assert(ownerMintAddress, 'Missing ownerMintAddress param');
+    assert(walletAddress, 'Missing walletAddress param');
+    const recoverNestedInstruction = createRecoverNestedInstruction(new PublicKey(nestedAccountAddress), new PublicKey(nestedMintAddress), new PublicKey(destinationAccountAddress), new PublicKey(ownerAccountAddress), new PublicKey(ownerMintAddress), new PublicKey(walletAddress));
+    return [recoverNestedInstruction];
+}
+/**
+ * Construct Staking Account Authorize Solana instructions
+ *
+ * @param {StakingAuthorize} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Staking Account Authorize instructions
+ */
+function stakingAuthorizeInstruction(data) {
+    const { params: { stakingAddress, oldAuthorizeAddress, newAuthorizeAddress, newWithdrawAddress }, } = data;
+    assert(stakingAddress, 'Missing stakingAddress param');
+    assert(oldAuthorizeAddress, 'Missing oldAuthorizeAddress param');
+    assert(newAuthorizeAddress, 'Missing newAuthorizeAddress param');
+    assert(newWithdrawAddress, 'Missing newWithdrawAddress param');
+    const tx = new Transaction();
+    const authorizeStaking = StakeProgram.authorize({
+        stakePubkey: new PublicKey(stakingAddress),
+        authorizedPubkey: new PublicKey(oldAuthorizeAddress),
+        newAuthorizedPubkey: new PublicKey(newAuthorizeAddress),
+        stakeAuthorizationType: StakeAuthorizationLayout.Staker,
+    });
+    const authorizeWithdraw = StakeProgram.authorize({
+        stakePubkey: new PublicKey(stakingAddress),
+        authorizedPubkey: new PublicKey(oldAuthorizeAddress),
+        newAuthorizedPubkey: new PublicKey(newAuthorizeAddress),
+        stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer,
+        custodianPubkey: new PublicKey(newWithdrawAddress),
+    });
+    tx.add(authorizeStaking);
+    tx.add(authorizeWithdraw);
+    return tx.instructions;
+}
+/**
+ * Construct Delegate Solana instructions
+ *
+ * @param {StakingActivate} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Delegate Solana instructions
+ */
+function stakingDelegateInstruction(data) {
+    const { params: { fromAddress, stakingAddress, validator }, } = data;
+    assert(fromAddress, 'Missing fromAddress param');
+    assert(stakingAddress, 'Missing stakingAddress param');
+    assert(validator, 'Missing validator param');
+    const tx = new Transaction();
+    const delegateStaking = StakeProgram.delegate({
+        stakePubkey: new PublicKey(stakingAddress),
+        authorizedPubkey: new PublicKey(fromAddress),
+        votePubkey: new PublicKey(validator),
+    });
+    tx.add(delegateStaking);
+    return tx.instructions;
+}
+/**
+ * Construct MintTo Solana instructions
+ *
+ * @param {MintTo} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing MintTo Solana instructions
+ */
+function mintToInstruction(data) {
+    const { params: { mintAddress, destinationAddress, authorityAddress, amount, programId }, } = data;
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(destinationAddress, 'Missing destinationAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assert(amount, 'Missing amount param');
+    const mint = new PublicKey(mintAddress);
+    const destination = new PublicKey(destinationAddress);
+    const authority = new PublicKey(authorityAddress);
+    let mintToInstr;
+    if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {
+        mintToInstr = createMintToInstruction(mint, destination, authority, BigInt(amount), [], TOKEN_2022_PROGRAM_ID);
+    }
+    else {
+        mintToInstr = createMintToInstruction(mint, destination, authority, BigInt(amount));
+    }
+    return [mintToInstr];
+}
+/**
+ * Construct Burn Solana instructions
+ *
+ * @param {Burn} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing Burn Solana instructions
+ */
+function burnInstruction(data) {
+    const { params: { mintAddress, accountAddress, authorityAddress, amount, programId }, } = data;
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(accountAddress, 'Missing accountAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assert(amount, 'Missing amount param');
+    const mint = new PublicKey(mintAddress);
+    const account = new PublicKey(accountAddress);
+    const authority = new PublicKey(authorityAddress);
+    let burnInstr;
+    if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {
+        burnInstr = createBurnInstruction(account, mint, authority, BigInt(amount), [], TOKEN_2022_PROGRAM_ID);
+    }
+    else {
+        burnInstr = createBurnInstruction(account, mint, authority, BigInt(amount));
+    }
+    return [burnInstr];
+}
+/**
+ * Process custom instruction - converts to TransactionInstruction
+ * Handles conversion from string-based format to TransactionInstruction format
+ *
+ * @param {CustomInstruction} data - the data containing the custom instruction
+ * @returns {TransactionInstruction[]} An array containing the custom instruction
+ */
+function customInstruction(data) {
+    const { params } = data;
+    assert(params.programId, 'Missing programId in custom instruction');
+    assert(params.keys && Array.isArray(params.keys), 'Missing or invalid keys in custom instruction');
+    assert(params.data !== undefined, 'Missing data in custom instruction');
+    // Convert string data to Buffer
+    let dataBuffer;
+    if (isValidBase64(params.data)) {
+        dataBuffer = Buffer.from(params.data, 'base64');
+    }
+    else if (isValidHex(params.data)) {
+        dataBuffer = Buffer.from(params.data, 'hex');
+    }
+    else {
+        // Fallback to UTF-8
+        dataBuffer = Buffer.from(params.data, 'utf8');
+    }
+    // Create a new TransactionInstruction with the converted data
+    const convertedInstruction = new TransactionInstruction({
+        programId: new PublicKey(params.programId),
+        keys: params.keys.map((key) => ({
+            pubkey: new PublicKey(key.pubkey),
+            isSigner: key.isSigner,
+            isWritable: key.isWritable,
+        })),
+        data: dataBuffer,
+    });
+    return [convertedInstruction];
+}
+/**
+ * Construct the sRFC-37 Token ACL `ThawPermissionlessIdempotent` instruction.
+ *
+ * The first nine accounts are fixed (authority, mint, tokenAccount, flagAccount, tokenAccountOwner,
+ * mintConfig, tokenProgram, systemProgram, gatingProgram) in that exact order and with the flags the
+ * program expects. Any gating-program extra accounts (resolved live by the caller) are appended
+ * afterwards. The instruction data is the single discriminator byte.
+ *
+ * @param {PermissionlessThawIdempotent} data - the data to build the instruction
+ * @returns {TransactionInstruction[]} An array containing the permissionless thaw instruction
+ */
+function permissionlessThawIdempotentInstruction(data) {
+    const { params: { authority, mint, tokenAccount, tokenAccountOwner, gatingProgram, flagAccount, mintConfig, extraAccounts }, } = data;
+    assert(authority, 'Missing authority param');
+    assert(mint, 'Missing mint param');
+    assert(tokenAccount, 'Missing tokenAccount param');
+    assert(tokenAccountOwner, 'Missing tokenAccountOwner param');
+    assert(gatingProgram, 'Missing gatingProgram param');
+    assert(flagAccount, 'Missing flagAccount param');
+    assert(mintConfig, 'Missing mintConfig param');
+    const tokenProgram = data.params.tokenProgram ?? TOKEN_2022_PROGRAM_ID.toString();
+    const systemProgram = data.params.systemProgram ?? SystemProgram.programId.toString();
+    const keys = [
+        { pubkey: new PublicKey(authority), isSigner: true, isWritable: false },
+        { pubkey: new PublicKey(mint), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(tokenAccount), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(flagAccount), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(tokenAccountOwner), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(mintConfig), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(tokenProgram), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(systemProgram), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(gatingProgram), isSigner: false, isWritable: false },
+        ...(extraAccounts ?? []).map((meta) => ({
+            pubkey: new PublicKey(meta.pubkey),
+            isSigner: meta.isSigner,
+            isWritable: meta.isWritable,
+        })),
+    ];
+    const thawInstruction = new TransactionInstruction({
+        keys,
+        programId: new PublicKey(TOKEN_ACL_PROGRAM_ID),
+        data: Buffer.from([THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR]),
+    });
+    return [thawInstruction];
+}
+function upsertAccountMeta(keys, meta) {
+    const existing = keys.find((account) => account.pubkey.equals(meta.pubkey));
+    if (existing) {
+        existing.isWritable = existing.isWritable || meta.isWritable;
+        existing.isSigner = existing.isSigner || meta.isSigner;
+    }
+    else {
+        keys.push(meta);
+    }
+}
+function buildTransferHookAccountMetas(extraAccountMetas) {
+    return extraAccountMetas.map((meta) => ({
+        pubkey: new PublicKey(meta.pubkey),
+        isSigner: meta.isSigner,
+        isWritable: meta.isWritable,
+    }));
+}
+function addTransferHookAccounts(instruction, extraAccountMetas) {
+    const extraMetas = buildTransferHookAccountMetas(extraAccountMetas);
+    for (const meta of extraMetas) {
+        upsertAccountMeta(instruction.keys, meta);
+    }
+}
+// ─── Confidential Transfer instruction builders ────────────────────────────
+//
+// All layouts verified against canonical Rust source:
+// solana-program/token-2022 `interface/src/extension/confidential_transfer/instruction.rs`
+//
+// Instruction builders are v0/v1-agnostic: they produce instruction data and
+// account metas only. The caller (Wallet Platform) assembles them into v1
+// transactions in the correct order.
+// Token-2022 CT sub-instruction discriminators (byte 1 after CT_EXT_DISCRIMINATOR)
+const CT_CONFIGURE_ACCOUNT_DISCRIMINATOR = 2;
+const CT_DEPOSIT_DISCRIMINATOR = 5;
+const CT_WITHDRAW_DISCRIMINATOR = 6;
+const CT_TRANSFER_DISCRIMINATOR = 7;
+const CT_APPLY_PENDING_BALANCE_DISCRIMINATOR = 8;
+// zk-elgamal-proof instruction discriminators
+const PROOF_VERIFY_PUBKEY_VALIDITY = 4;
+const PROOF_VERIFY_EQUALITY = 3;
+const PROOF_VERIFY_VALIDITY_3HANDLES = 12;
+const PROOF_VERIFY_RANGE_U128 = 7;
+/**
+ * Validates that a string can be safely converted to BigInt.
+ * Accepts non-negative integer strings (e.g. "1000000", "0").
+ * Also rejects values that would overflow u64 (2^64 - 1).
+ */
+function assertValidAmountString(value, fieldName) {
+    assert(value, `Missing ${fieldName} param`);
+    if (!/^\d+$/.test(value)) {
+        throw new Error(`Invalid ${fieldName}: expected non-negative integer string, got "${value}"`);
+    }
+    if (BigInt(value) > 0xffffffffffffffffn) {
+        throw new Error(`Invalid ${fieldName}: value exceeds u64 max (18446744073709551615), got "${value}"`);
+    }
+}
+/**
+ * Validates that a number fits in a u8 (0-255).
+ */
+function assertValidU8(value, fieldName) {
+    if (!Number.isInteger(value) || value < 0 || value > 255) {
+        throw new Error(`Invalid ${fieldName}: expected u8 (0-255), got ${value}`);
+    }
+}
+/**
+ * Validates that a number fits in a signed i8 (-128 to 127).
+ */
+function assertValidI8(value, fieldName) {
+    if (!Number.isInteger(value) || value < -128 || value > 127) {
+        throw new Error(`Invalid ${fieldName}: expected i8 (-128 to 127), got ${value}`);
+    }
+}
+// Buffer layouts for CT instructions with multi-byte fields
+const configureAccountDataLayout = struct([
+    u8('instruction'), // 27
+    u8('confidentialTransferInstruction'), // 2
+    blob(32, 'elgamalPubkey'), // new_account_elgamal_pubkey
+    blob(36, 'decryptableZeroBalance'),
+    blob(8, 'maximumPendingBalanceCreditCounter'),
+    s8('proofInstructionOffset'), // i8 — signed: negative = proof is before this instruction
+]); // span = 79
+const applyPendingBalanceDataLayout = struct([
+    u8('instruction'), // 27
+    u8('confidentialTransferInstruction'), // 8
+    blob(8, 'expectedPendingBalanceCreditCounter'),
+    blob(36, 'newDecryptableAvailableBalance'),
+]); // span = 46
+const withdrawDataLayout = struct([
+    u8('instruction'), // 27
+    u8('confidentialTransferInstruction'), // 6
+    blob(8, 'amount'),
+    u8('decimals'),
+    blob(36, 'newDecryptableAvailableBalance'),
+    s8('equalityProofInstructionOffset'), // i8
+    s8('rangeProofInstructionOffset'), // i8
+]); // span = 49
+const transferDataLayout = struct([
+    u8('instruction'), // 27
+    u8('confidentialTransferInstruction'), // 7
+    blob(36, 'newSourceDecryptableAvailableBalance'),
+    blob(64, 'transferAmountAuditorCiphertextLo'),
+    blob(64, 'transferAmountAuditorCiphertextHi'),
+    s8('equalityProofInstructionOffset'), // i8
+    s8('ciphertextValidityProofInstructionOffset'), // i8
+    s8('rangeProofInstructionOffset'), // i8
+]); // span = 169
+/**
+ * Build a ConfigureAccount instruction for Token-2022 confidential transfers.
+ *
+ * Registers an ElGamal pubkey + AES zero ciphertext on a token account so it
+ * can send and receive confidential transfers. Must be accompanied by a
+ * VerifyPubkeyValidity proof instruction (inline or context state).
+ */
+function configureConfidentialTransferAccountInstruction(data) {
+    const { params: { tokenAddress, mintAddress, authorityAddress, elgamalPubkey, instructionsSysvarOrContextStateAddress, decryptableZeroBalance, maximumPendingBalanceCreditCounter, proofInstructionOffset, }, } = data;
+    assert(tokenAddress, 'Missing tokenAddress param');
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assert(elgamalPubkey, 'Missing elgamalPubkey param');
+    assert(decryptableZeroBalance, 'Missing decryptableZeroBalance param');
+    assertValidAmountString(maximumPendingBalanceCreditCounter, 'maximumPendingBalanceCreditCounter');
+    assertValidI8(proofInstructionOffset, 'proofInstructionOffset');
+    const keys = [
+        { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },
+        {
+            pubkey: new PublicKey(instructionsSysvarOrContextStateAddress || INSTRUCTIONS_SYSVAR_ADDRESS),
+            isSigner: false,
+            isWritable: false,
+        },
+        { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },
+    ];
+    const decryptableBytes = Buffer.from(decryptableZeroBalance, 'hex');
+    assert(decryptableBytes.length === 36, 'decryptableZeroBalance must be 36 bytes');
+    const elgamalPubkeyBytes = Buffer.from(elgamalPubkey, 'hex');
+    assert(elgamalPubkeyBytes.length === 32, 'elgamalPubkey must be 32 bytes');
+    const dataBuffer = Buffer.alloc(configureAccountDataLayout.span);
+    const counterBuffer = Buffer.alloc(8);
+    counterBuffer.writeBigUInt64LE(BigInt(maximumPendingBalanceCreditCounter));
+    configureAccountDataLayout.encode({
+        instruction: CT_EXT_DISCRIMINATOR,
+        confidentialTransferInstruction: CT_CONFIGURE_ACCOUNT_DISCRIMINATOR,
+        elgamalPubkey: elgamalPubkeyBytes,
+        decryptableZeroBalance: decryptableBytes,
+        maximumPendingBalanceCreditCounter: counterBuffer,
+        proofInstructionOffset,
+    }, dataBuffer);
+    return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];
+}
+/**
+ * Build an ApplyPendingBalance instruction.
+ *
+ * Credits pending balance into available balance. Idempotent — no-op if 0
+ * pending. In v1 transactions, always instruction #1.
+ */
+function applyPendingBalanceInstruction(data) {
+    const { params: { tokenAddress, authorityAddress, expectedPendingBalanceCreditCounter, newDecryptableAvailableBalance }, } = data;
+    assert(tokenAddress, 'Missing tokenAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assertValidAmountString(expectedPendingBalanceCreditCounter, 'expectedPendingBalanceCreditCounter');
+    assert(newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');
+    const keys = [
+        { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },
+    ];
+    const decryptableBytes = Buffer.from(newDecryptableAvailableBalance, 'hex');
+    assert(decryptableBytes.length === 36, 'newDecryptableAvailableBalance must be 36 bytes');
+    const dataBuffer = Buffer.alloc(applyPendingBalanceDataLayout.span);
+    const counterBuffer = Buffer.alloc(8);
+    counterBuffer.writeBigUInt64LE(BigInt(expectedPendingBalanceCreditCounter));
+    applyPendingBalanceDataLayout.encode({
+        instruction: CT_EXT_DISCRIMINATOR,
+        confidentialTransferInstruction: CT_APPLY_PENDING_BALANCE_DISCRIMINATOR,
+        expectedPendingBalanceCreditCounter: counterBuffer,
+        newDecryptableAvailableBalance: decryptableBytes,
+    }, dataBuffer);
+    return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];
+}
+/**
+ * Build a Deposit instruction (public → confidential conversion).
+ *
+ * Moves public SPL token balance into confidential pending balance.
+ * No proof required — the amount is public.
+ */
+function confidentialDepositInstruction(data) {
+    const { params: { tokenAddress, mintAddress, authorityAddress, amount, decimals }, } = data;
+    assert(tokenAddress, 'Missing tokenAddress param');
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assertValidAmountString(amount, 'amount');
+    assertValidU8(decimals, 'decimals');
+    const keys = [
+        { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },
+    ];
+    // Layout: [27][5] + amount(u64) + decimals(u8) = 11 bytes
+    const dataBuffer = Buffer.alloc(11);
+    dataBuffer.writeUInt8(CT_EXT_DISCRIMINATOR, 0);
+    dataBuffer.writeUInt8(CT_DEPOSIT_DISCRIMINATOR, 1);
+    dataBuffer.writeBigUInt64LE(BigInt(amount), 2);
+    dataBuffer.writeUInt8(decimals, 10);
+    return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];
+}
+/**
+ * Build a Withdraw instruction (confidential → public conversion).
+ *
+ * Requires equality + range proof verification (inline or context state).
+ */
+function confidentialWithdrawInstruction(data) {
+    const { params: { tokenAddress, mintAddress, authorityAddress, instructionsSysvarAddress, equalityProofContextStateAddress, rangeProofContextStateAddress, amount, decimals, newDecryptableAvailableBalance, equalityProofInstructionOffset, rangeProofInstructionOffset, }, } = data;
+    assert(tokenAddress, 'Missing tokenAddress param');
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assertValidAmountString(amount, 'amount');
+    assertValidU8(decimals, 'decimals');
+    assertValidI8(equalityProofInstructionOffset, 'equalityProofInstructionOffset');
+    assertValidI8(rangeProofInstructionOffset, 'rangeProofInstructionOffset');
+    assert(newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');
+    // Assert context state addresses are provided when offset == 0 (context state mode)
+    if (equalityProofInstructionOffset === 0) {
+        assert(equalityProofContextStateAddress, 'equalityProofContextStateAddress is required when equalityProofInstructionOffset is 0 (context state mode)');
+    }
+    if (rangeProofInstructionOffset === 0) {
+        assert(rangeProofContextStateAddress, 'rangeProofContextStateAddress is required when rangeProofInstructionOffset is 0 (context state mode)');
+    }
+    const keys = [
+        { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },
+    ];
+    // Add instructions sysvar if any proof is inline (offset != 0)
+    const hasInlineProof = equalityProofInstructionOffset !== 0 || rangeProofInstructionOffset !== 0;
+    if (hasInlineProof || instructionsSysvarAddress) {
+        keys.push({
+            pubkey: new PublicKey(instructionsSysvarAddress || INSTRUCTIONS_SYSVAR_ADDRESS),
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+    // Add context state accounts for pre-verified proofs (offset == 0)
+    if (equalityProofInstructionOffset === 0 && equalityProofContextStateAddress) {
+        keys.push({ pubkey: new PublicKey(equalityProofContextStateAddress), isSigner: false, isWritable: false });
+    }
+    if (rangeProofInstructionOffset === 0 && rangeProofContextStateAddress) {
+        keys.push({ pubkey: new PublicKey(rangeProofContextStateAddress), isSigner: false, isWritable: false });
+    }
+    keys.push({ pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false });
+    const decryptableBytes = Buffer.from(newDecryptableAvailableBalance, 'hex');
+    assert(decryptableBytes.length === 36, 'newDecryptableAvailableBalance must be 36 bytes');
+    const dataBuffer = Buffer.alloc(withdrawDataLayout.span);
+    const amountBuffer = Buffer.alloc(8);
+    amountBuffer.writeBigUInt64LE(BigInt(amount));
+    withdrawDataLayout.encode({
+        instruction: CT_EXT_DISCRIMINATOR,
+        confidentialTransferInstruction: CT_WITHDRAW_DISCRIMINATOR,
+        amount: amountBuffer,
+        decimals,
+        newDecryptableAvailableBalance: decryptableBytes,
+        equalityProofInstructionOffset,
+        rangeProofInstructionOffset,
+    }, dataBuffer);
+    return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];
+}
+/**
+ * Build a confidential Transfer instruction.
+ *
+ * Requires equality + ciphertext validity + range proof verification (inline or context state).
+ */
+function confidentialTransferInstruction(data) {
+    const { params: { sourceTokenAddress, mintAddress, destinationTokenAddress, authorityAddress, instructionsSysvarAddress, equalityProofContextStateAddress, ciphertextValidityProofContextStateAddress, rangeProofContextStateAddress, newSourceDecryptableAvailableBalance, transferAmountAuditorCiphertextLo, transferAmountAuditorCiphertextHi, equalityProofInstructionOffset, ciphertextValidityProofInstructionOffset, rangeProofInstructionOffset, }, } = data;
+    assert(sourceTokenAddress, 'Missing sourceTokenAddress param');
+    assert(mintAddress, 'Missing mintAddress param');
+    assert(destinationTokenAddress, 'Missing destinationTokenAddress param');
+    assert(authorityAddress, 'Missing authorityAddress param');
+    assert(newSourceDecryptableAvailableBalance, 'Missing newSourceDecryptableAvailableBalance param');
+    assert(transferAmountAuditorCiphertextLo, 'Missing transferAmountAuditorCiphertextLo param');
+    assert(transferAmountAuditorCiphertextHi, 'Missing transferAmountAuditorCiphertextHi param');
+    assertValidI8(equalityProofInstructionOffset, 'equalityProofInstructionOffset');
+    assertValidI8(ciphertextValidityProofInstructionOffset, 'ciphertextValidityProofInstructionOffset');
+    assertValidI8(rangeProofInstructionOffset, 'rangeProofInstructionOffset');
+    // Assert context state addresses are provided when offset == 0 (context state mode)
+    if (equalityProofInstructionOffset === 0) {
+        assert(equalityProofContextStateAddress, 'equalityProofContextStateAddress is required when equalityProofInstructionOffset is 0 (context state mode)');
+    }
+    if (ciphertextValidityProofInstructionOffset === 0) {
+        assert(ciphertextValidityProofContextStateAddress, 'ciphertextValidityProofContextStateAddress is required when ciphertextValidityProofInstructionOffset is 0 (context state mode)');
+    }
+    if (rangeProofInstructionOffset === 0) {
+        assert(rangeProofContextStateAddress, 'rangeProofContextStateAddress is required when rangeProofInstructionOffset is 0 (context state mode)');
+    }
+    const keys = [
+        { pubkey: new PublicKey(sourceTokenAddress), isSigner: false, isWritable: true },
+        { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },
+        { pubkey: new PublicKey(destinationTokenAddress), isSigner: false, isWritable: true },
+    ];
+    // Add instructions sysvar if any proof is inline (offset != 0)
+    const hasInlineProof = equalityProofInstructionOffset !== 0 ||
+        ciphertextValidityProofInstructionOffset !== 0 ||
+        rangeProofInstructionOffset !== 0;
+    if (hasInlineProof || instructionsSysvarAddress) {
+        keys.push({
+            pubkey: new PublicKey(instructionsSysvarAddress || INSTRUCTIONS_SYSVAR_ADDRESS),
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+    // Add context state accounts for pre-verified proofs (offset == 0)
+    if (equalityProofInstructionOffset === 0 && equalityProofContextStateAddress) {
+        keys.push({ pubkey: new PublicKey(equalityProofContextStateAddress), isSigner: false, isWritable: false });
+    }
+    if (ciphertextValidityProofInstructionOffset === 0 && ciphertextValidityProofContextStateAddress) {
+        keys.push({
+            pubkey: new PublicKey(ciphertextValidityProofContextStateAddress),
+            isSigner: false,
+            isWritable: false,
+        });
+    }
+    if (rangeProofInstructionOffset === 0 && rangeProofContextStateAddress) {
+        keys.push({ pubkey: new PublicKey(rangeProofContextStateAddress), isSigner: false, isWritable: false });
+    }
+    keys.push({ pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false });
+    const decryptableBytes = Buffer.from(newSourceDecryptableAvailableBalance, 'hex');
+    assert(decryptableBytes.length === 36, 'newSourceDecryptableAvailableBalance must be 36 bytes');
+    const auditorLoBytes = Buffer.from(transferAmountAuditorCiphertextLo, 'hex');
+    assert(auditorLoBytes.length === 64, 'transferAmountAuditorCiphertextLo must be 64 bytes');
+    const auditorHiBytes = Buffer.from(transferAmountAuditorCiphertextHi, 'hex');
+    assert(auditorHiBytes.length === 64, 'transferAmountAuditorCiphertextHi must be 64 bytes');
+    const dataBuffer = Buffer.alloc(transferDataLayout.span);
+    transferDataLayout.encode({
+        instruction: CT_EXT_DISCRIMINATOR,
+        confidentialTransferInstruction: CT_TRANSFER_DISCRIMINATOR,
+        newSourceDecryptableAvailableBalance: decryptableBytes,
+        transferAmountAuditorCiphertextLo: auditorLoBytes,
+        transferAmountAuditorCiphertextHi: auditorHiBytes,
+        equalityProofInstructionOffset,
+        ciphertextValidityProofInstructionOffset,
+        rangeProofInstructionOffset,
+    }, dataBuffer);
+    return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];
+}
+// ─── zk-elgamal-proof verification instruction builders ────────────────────
+/**
+ * Build a VerifyPubkeyValidity proof instruction.
+ *
+ * Used with ConfigureAccount to prove knowledge of the ElGamal secret key.
+ * Discriminator: [4]
+ */
+function verifyPubkeyValidityInstruction(data, zkProofProgramId) {
+    const { params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress }, } = data;
+    const keys = [];
+    if (contextStateAccountAddress && contextStateAuthorityAddress) {
+        keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });
+        keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });
+    }
+    // Use buildProofDataOrOffsetBuffer to support both inline proof and context state offset
+    const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_PUBKEY_VALIDITY, proofData, undefined, true);
+    return [
+        new TransactionInstruction({
+            keys,
+            programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),
+            data: dataBuffer,
+        }),
+    ];
+}
+/**
+ * Build a VerifyCiphertextCommitmentEquality proof instruction.
+ *
+ * Used with Transfer and Withdraw. Discriminator: [3]
+ */
+function verifyEqualityProofInstruction(data, zkProofProgramId) {
+    const { params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset }, } = data;
+    const keys = [];
+    if (contextStateAccountAddress && contextStateAuthorityAddress) {
+        keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });
+        keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });
+    }
+    const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_EQUALITY, proofData, offset, true);
+    return [
+        new TransactionInstruction({
+            keys,
+            programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),
+            data: dataBuffer,
+        }),
+    ];
+}
+/**
+ * Build a VerifyBatchedGroupedCiphertext3HandlesValidity proof instruction.
+ *
+ * Used with Transfer. Discriminator: [12]
+ */
+function verifyValidityProofInstruction(data, zkProofProgramId) {
+    const { params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset }, } = data;
+    const keys = [];
+    if (contextStateAccountAddress && contextStateAuthorityAddress) {
+        keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });
+        keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });
+    }
+    const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_VALIDITY_3HANDLES, proofData, offset, true);
+    return [
+        new TransactionInstruction({
+            keys,
+            programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),
+            data: dataBuffer,
+        }),
+    ];
+}
+/**
+ * Build a VerifyBatchedRangeProofU128 proof instruction.
+ *
+ * Used with Transfer. Discriminator: [7]
+ * Note: range proofs do not use a context state account in the same way as
+ * equality/validity proofs — the proof is either inline or read from a
+ * record account at the given offset.
+ */
+function verifyRangeProofInstruction(data, zkProofProgramId) {
+    const { params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset }, } = data;
+    const keys = [];
+    if (contextStateAccountAddress && contextStateAuthorityAddress) {
+        keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });
+        keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });
+    }
+    const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_RANGE_U128, proofData, offset, false);
+    return [
+        new TransactionInstruction({
+            keys,
+            programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),
+            data: dataBuffer,
+        }),
+    ];
+}
+/**
+ * Build proof instruction data from either inline proof bytes or a context
+ * state account offset.
+ *
+ * If proofData is provided: [discriminator: u8] + [proof_data: variable]
+ * If offset is provided: [discriminator: u8] + [offset: u32 LE]
+ *
+ * @param useUInt32 - true for equality/validity (writeUInt32LE), false for range (writeInt32LE)
+ */
+function buildProofDataOrOffsetBuffer(discriminator, proofData, offset, useUInt32 = true) {
+    if (proofData) {
+        const proofBytes = Buffer.from(proofData, 'hex');
+        return Buffer.concat([Buffer.from([discriminator]), proofBytes]);
+    }
+    const offsetBuffer = Buffer.alloc(4);
+    if (useUInt32) {
+        offsetBuffer.writeUInt32LE(offset ?? 0, 0);
+    }
+    else {
+        offsetBuffer.writeInt32LE(offset ?? 0, 0);
+    }
+    return Buffer.concat([Buffer.from([discriminator]), offsetBuffer]);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"solInstructionFactory.js","sourceRoot":"","sources":["../../../src/lib/solInstructionFactory.ts"],"names":[],"mappings":"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","sourcesContent":["import { SolStakingTypeEnum } from '@bitgo/public-types';\nimport { SolCoin } from '@bitgo-beta/statics';\nimport {\n  createAssociatedTokenAccountIdempotentInstruction,\n  createCloseAccountInstruction,\n  createMintToInstruction,\n  createBurnInstruction,\n  createRecoverNestedInstruction,\n  createTransferCheckedInstruction,\n  createTransferCheckedWithFeeInstruction,\n  TOKEN_2022_PROGRAM_ID,\n  TOKEN_PROGRAM_ID,\n  createApproveInstruction,\n  createReallocateInstruction,\n  ExtensionType,\n} from '@solana/spl-token';\nimport { struct, u8, s8, blob } from '@solana/buffer-layout';\nimport {\n  AccountMeta,\n  Authorized,\n  Lockup,\n  PublicKey,\n  StakeAuthorizationLayout,\n  StakeProgram,\n  SystemProgram,\n  Transaction,\n  TransactionInstruction,\n  ComputeBudgetProgram,\n} from '@solana/web3.js';\nimport assert from 'assert';\nimport BigNumber from 'bignumber.js';\nimport {\n  INSTRUCTIONS_SYSVAR_ADDRESS,\n  InstructionBuilderTypes,\n  MEMO_PROGRAM_PK,\n  THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR,\n  TOKEN_ACL_PROGRAM_ID,\n  ZK_ELGAMAL_PROOF_PROGRAM_ID,\n  CT_EXT_DISCRIMINATOR,\n} from './constants';\nimport {\n  ApplyPendingBalance,\n  AtaClose,\n  AtaInit,\n  ReallocateConfidentialTransferAccount,\n  AtaRecoverNested,\n  ConfidentialDeposit,\n  ConfidentialTransfer,\n  ConfidentialWithdraw,\n  ConfigureConfidentialTransferAccount,\n  ExtraAccountMeta,\n  InstructionParams,\n  Memo,\n  MintTo,\n  Burn,\n  Nonce,\n  PermissionlessThawIdempotent,\n  StakingActivate,\n  StakingAuthorize,\n  StakingDeactivate,\n  StakingDelegate,\n  StakingWithdraw,\n  TokenTransfer,\n  Transfer,\n  VerifyEqualityProof,\n  VerifyPubkeyValidity,\n  VerifyRangeProof,\n  VerifyValidityProof,\n  WalletInit,\n  SetComputeUnitLimit,\n  SetPriorityFee,\n  CustomInstruction,\n  Approve,\n} from './iface';\nimport { computeTransferFee, getSolTokenFromTokenName, isValidBase64, isValidHex } from './utils';\nimport { depositSolInstructions, withdrawStakeInstructions } from './jitoStakePoolOperations';\n\n/**\n * Construct Solana instructions from instructions params\n *\n * @param {InstructionParams} instructionToBuild - the data containing the instruction params\n * @returns {TransactionInstruction[]} An array containing supported Solana instructions\n */\nexport function solInstructionFactory(\n  instructionToBuild: InstructionParams,\n  zkProofProgramId?: string\n): TransactionInstruction[] {\n  switch (instructionToBuild.type) {\n    case InstructionBuilderTypes.NonceAdvance:\n      return advanceNonceInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Memo:\n      return memoInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Transfer:\n      return transferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.TokenTransfer:\n      return tokenTransferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Approve:\n      return approveInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CreateNonceAccount:\n      return createNonceAccountInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingActivate:\n      return stakingInitializeInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingDeactivate:\n      return stakingDeactivateInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingWithdraw:\n      return stakingWithdrawInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CreateAssociatedTokenAccount:\n      return createATAInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ReallocateConfidentialTransferAccount:\n      return reallocateConfidentialTransferAccountInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CloseAssociatedTokenAccount:\n      return closeATAInstruction(instructionToBuild);\n    case InstructionBuilderTypes.RecoverNestedAssociatedTokenAccount:\n      return recoverNestedATAInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingAuthorize:\n      return stakingAuthorizeInstruction(instructionToBuild);\n    case InstructionBuilderTypes.StakingDelegate:\n      return stakingDelegateInstruction(instructionToBuild);\n    case InstructionBuilderTypes.SetComputeUnitLimit:\n      return setComputeUnitLimitInstruction(instructionToBuild);\n    case InstructionBuilderTypes.SetPriorityFee:\n      return fetchPriorityFeeInstruction(instructionToBuild);\n    case InstructionBuilderTypes.MintTo:\n      return mintToInstruction(instructionToBuild);\n    case InstructionBuilderTypes.Burn:\n      return burnInstruction(instructionToBuild);\n    case InstructionBuilderTypes.CustomInstruction:\n      return customInstruction(instructionToBuild);\n    case InstructionBuilderTypes.PermissionlessThawIdempotent:\n      return permissionlessThawIdempotentInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ConfigureConfidentialTransferAccount:\n      return configureConfidentialTransferAccountInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ApplyPendingBalance:\n      return applyPendingBalanceInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ConfidentialDeposit:\n      return confidentialDepositInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ConfidentialWithdraw:\n      return confidentialWithdrawInstruction(instructionToBuild);\n    case InstructionBuilderTypes.ConfidentialTransfer:\n      return confidentialTransferInstruction(instructionToBuild);\n    case InstructionBuilderTypes.VerifyPubkeyValidity:\n      return verifyPubkeyValidityInstruction(instructionToBuild, zkProofProgramId);\n    case InstructionBuilderTypes.VerifyEqualityProof:\n      return verifyEqualityProofInstruction(instructionToBuild, zkProofProgramId);\n    case InstructionBuilderTypes.VerifyValidityProof:\n      return verifyValidityProofInstruction(instructionToBuild, zkProofProgramId);\n    case InstructionBuilderTypes.VerifyRangeProof:\n      return verifyRangeProofInstruction(instructionToBuild, zkProofProgramId);\n    default:\n      throw new Error(`Invalid instruction type or not supported`);\n  }\n}\n\n/**\n * Construct Advance Nonce Solana instructions\n *\n * @param {Nonce} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Advance Nonce Solana instruction\n */\nfunction advanceNonceInstruction(data: Nonce): TransactionInstruction[] {\n  const {\n    params: { authWalletAddress, walletNonceAddress },\n  } = data;\n  assert(authWalletAddress, 'Missing authWalletAddress param');\n  assert(walletNonceAddress, 'Missing walletNonceAddress param');\n  const nonceInstruction = SystemProgram.nonceAdvance({\n    noncePubkey: new PublicKey(walletNonceAddress),\n    authorizedPubkey: new PublicKey(authWalletAddress),\n  });\n  return [nonceInstruction];\n}\n\nfunction setComputeUnitLimitInstruction(instructionToBuild: SetComputeUnitLimit): TransactionInstruction[] {\n  const setComputeUnitLimit = ComputeBudgetProgram.setComputeUnitLimit({\n    units: instructionToBuild.params.units,\n  });\n\n  return [setComputeUnitLimit];\n}\n\nfunction fetchPriorityFeeInstruction(instructionToBuild: SetPriorityFee): TransactionInstruction[] {\n  const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({\n    microLamports: instructionToBuild.params.fee,\n  });\n\n  return [addPriorityFee];\n}\n\n/**\n * Construct Memo Solana instructions\n *\n * @param {Memo} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Memo Solana instruction\n */\nfunction memoInstruction(data: Memo): TransactionInstruction[] {\n  const {\n    params: { memo },\n  } = data;\n  assert(memo, 'Missing memo param');\n  const memoInstruction = new TransactionInstruction({\n    keys: [],\n    programId: new PublicKey(MEMO_PROGRAM_PK),\n    data: Buffer.from(memo),\n  });\n  return [memoInstruction];\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction transferInstruction(data: Transfer): TransactionInstruction[] {\n  const {\n    params: { fromAddress, toAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(toAddress, 'Missing toAddress param');\n  assert(amount, 'Missing toAddress param');\n  const transferInstruction = SystemProgram.transfer({\n    fromPubkey: new PublicKey(fromAddress),\n    toPubkey: new PublicKey(toAddress),\n    lamports: parseInt(amount, 10),\n  });\n  return [transferInstruction];\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction tokenTransferInstruction(data: TokenTransfer): TransactionInstruction[] {\n  const {\n    params: { fromAddress, toAddress, amount, tokenName, sourceAddress },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress (owner) param');\n  assert(toAddress, 'Missing toAddress param');\n  assert(amount, 'Missing amount param');\n  assert(tokenName, 'Missing token name');\n  assert(sourceAddress, 'Missing ata address');\n  const token = getSolTokenFromTokenName(data.params.tokenName);\n  let tokenAddress: string;\n  let programId: string | undefined;\n  let decimalPlaces: number;\n  if (data.params.tokenAddress && data.params.decimalPlaces != null) {\n    tokenAddress = data.params.tokenAddress;\n    decimalPlaces = data.params.decimalPlaces;\n    programId = data.params.programId;\n  } else if (token) {\n    assert(token instanceof SolCoin);\n    tokenAddress = token.tokenAddress;\n    decimalPlaces = token.decimalPlaces;\n    programId = token.programId;\n  } else {\n    throw new Error('Invalid token name, got:' + data.params.tokenName);\n  }\n\n  let transferInstruction: TransactionInstruction;\n  const instructions: TransactionInstruction[] = [];\n\n  if (programId === TOKEN_2022_PROGRAM_ID.toString()) {\n    // Use transferCheckedWithFee when the token has a TransferFee extension (or an explicit fee is\n    // supplied). The instruction fails on-chain if the expected fee != live config, protecting the\n    // customer from a mid-flight fee change. PRD 3.6.\n    const feeConfig = token instanceof SolCoin ? token.tokenExtensions?.transferFee : undefined;\n    const fee =\n      data.params.fee ??\n      (feeConfig ? computeTransferFee(amount, feeConfig.transferFeeBasisPoints, feeConfig.maximumFee) : undefined);\n    if (fee !== undefined) {\n      transferInstruction = createTransferCheckedWithFeeInstruction(\n        new PublicKey(sourceAddress),\n        new PublicKey(tokenAddress),\n        new PublicKey(toAddress),\n        new PublicKey(fromAddress),\n        BigInt(amount),\n        decimalPlaces,\n        BigInt(fee),\n        [],\n        TOKEN_2022_PROGRAM_ID\n      );\n    } else {\n      transferInstruction = createTransferCheckedInstruction(\n        new PublicKey(sourceAddress),\n        new PublicKey(tokenAddress),\n        new PublicKey(toAddress),\n        new PublicKey(fromAddress),\n        BigInt(amount),\n        decimalPlaces,\n        [],\n        TOKEN_2022_PROGRAM_ID\n      );\n    }\n    // Append any resolved Transfer Hook extra accounts. These are resolved live by\n    // the caller (offline builders never fetch) and supplied in the required order.\n    if (data.params.transferHookAccounts?.length) {\n      addTransferHookAccounts(transferInstruction, data.params.transferHookAccounts);\n    }\n  } else {\n    transferInstruction = createTransferCheckedInstruction(\n      new PublicKey(sourceAddress),\n      new PublicKey(tokenAddress),\n      new PublicKey(toAddress),\n      new PublicKey(fromAddress),\n      BigInt(amount),\n      decimalPlaces\n    );\n  }\n  instructions.push(transferInstruction);\n  return instructions;\n}\n\n/**\n * Construct Transfer Solana instructions\n *\n * @param {Transfer} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Transfer Solana instruction\n */\nfunction approveInstruction(data: Approve): TransactionInstruction[] {\n  const {\n    params: { accountAddress, delegateAddress, ownerAddress, amount, programId },\n  } = data;\n  assert(accountAddress, 'Missing fromAddress (owner) param');\n  assert(delegateAddress, 'Missing toAddress param');\n  assert(ownerAddress, 'Missing ownerAddress param');\n  assert(programId, 'Missing programId param');\n  assert(amount, 'Missing amount param');\n  return [\n    createApproveInstruction(\n      new PublicKey(accountAddress),\n      new PublicKey(delegateAddress),\n      new PublicKey(ownerAddress),\n      BigInt(amount),\n      undefined,\n      programId === undefined ? undefined : new PublicKey(programId)\n    ),\n  ];\n}\n\n/**\n * Construct Create and Initialize Nonce Solana instructions\n *\n * @param {WalletInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create and Initialize Nonce Solana instruction\n */\nfunction createNonceAccountInstruction(data: WalletInit): TransactionInstruction[] {\n  const {\n    params: { fromAddress, nonceAddress, authAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(nonceAddress, 'Missing nonceAddress param');\n  assert(authAddress, 'Missing authAddress param');\n  assert(amount, 'Missing amount param');\n  const nonceAccountInstruction = SystemProgram.createNonceAccount({\n    fromPubkey: new PublicKey(fromAddress),\n    noncePubkey: new PublicKey(nonceAddress),\n    authorizedPubkey: new PublicKey(authAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n  return nonceAccountInstruction.instructions;\n}\n\n/**\n * Construct Create Staking Account and Delegate Solana instructions\n *\n * @param {StakingActivate} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Create Staking Account and Delegate Solana instructions\n */\nfunction stakingInitializeInstruction(data: StakingActivate): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, amount, validator, stakingType, extraParams },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(amount, 'Missing amount param');\n  assert(validator, 'Missing validator param');\n\n  const fromPubkey = new PublicKey(fromAddress);\n  const stakePubkey = new PublicKey(stakingAddress);\n  const validatorPubkey = new PublicKey(validator);\n  const tx = new Transaction();\n\n  switch (stakingType) {\n    case SolStakingTypeEnum.JITO: {\n      assert(extraParams !== undefined, 'Missing extraParams param');\n      const instructions = depositSolInstructions(\n        {\n          stakePoolAddress: stakePubkey,\n          from: fromPubkey,\n          lamports: BigInt(amount),\n        },\n        extraParams.stakePoolData,\n        !!extraParams.createAssociatedTokenAccount\n      );\n      tx.add(...instructions);\n      break;\n    }\n\n    case SolStakingTypeEnum.MARINADE: {\n      const walletInitStaking = StakeProgram.createAccount({\n        fromPubkey,\n        stakePubkey,\n        authorized: new Authorized(validatorPubkey, fromPubkey), // staker and withdrawer\n        lockup: new Lockup(0, 0, fromPubkey), // No minimum epoch to withdraw\n        lamports: new BigNumber(amount).toNumber(),\n      });\n      tx.add(walletInitStaking);\n      break;\n    }\n\n    case SolStakingTypeEnum.NATIVE: {\n      const walletInitStaking = StakeProgram.createAccount({\n        fromPubkey,\n        stakePubkey,\n        authorized: new Authorized(fromPubkey, fromPubkey), // staker and withdrawer\n        lockup: new Lockup(0, 0, fromPubkey), // No minimum epoch to withdraw\n        lamports: new BigNumber(amount).toNumber(),\n      });\n      tx.add(walletInitStaking);\n\n      const delegateStaking = StakeProgram.delegate({\n        stakePubkey: new PublicKey(stakingAddress),\n        authorizedPubkey: new PublicKey(fromAddress),\n        votePubkey: new PublicKey(validator),\n      });\n      tx.add(delegateStaking);\n      break;\n    }\n\n    default: {\n      const unreachable: never = stakingType;\n      throw new Error(`Unknown staking type ${unreachable}`);\n    }\n  }\n\n  return tx.instructions;\n}\n\n/**\n * Construct staking deactivate Solana instructions\n *\n * @param {StakingDeactivate} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing staking deactivate instruction\n */\nfunction stakingDeactivateInstruction(data: StakingDeactivate): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, amount, unstakingAddress, recipients, stakingType, extraParams },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n\n  switch (stakingType) {\n    case SolStakingTypeEnum.JITO: {\n      assert(stakingAddress, 'Missing stakingAddress param');\n      assert(unstakingAddress, 'Missing unstakingAddress param');\n      assert(amount, 'Missing amount param');\n      assert(extraParams, 'Missing extraParams param');\n\n      const tx = new Transaction();\n      tx.add(\n        ...withdrawStakeInstructions(\n          {\n            stakePoolAddress: new PublicKey(stakingAddress),\n            tokenOwner: new PublicKey(fromAddress),\n            destinationStakeAccount: new PublicKey(unstakingAddress),\n            validatorAddress: new PublicKey(extraParams.validatorAddress),\n            transferAuthority: new PublicKey(extraParams.transferAuthorityAddress),\n            poolAmount: amount,\n          },\n          extraParams.stakePoolData\n        )\n      );\n      return tx.instructions;\n    }\n\n    case SolStakingTypeEnum.MARINADE: {\n      assert(recipients, 'Missing recipients param');\n\n      const tx = new Transaction();\n      const toPubkeyAddress = new PublicKey(recipients[0].address || '');\n      const transferInstruction = SystemProgram.transfer({\n        fromPubkey: new PublicKey(fromAddress),\n        toPubkey: toPubkeyAddress,\n        lamports: parseInt(recipients[0].amount, 10),\n      });\n\n      tx.add(transferInstruction);\n      return tx.instructions;\n    }\n\n    case SolStakingTypeEnum.NATIVE: {\n      assert(stakingAddress, 'Missing stakingAddress param');\n\n      if (data.params.amount && data.params.unstakingAddress) {\n        const tx = new Transaction();\n        const unstakingAddress = new PublicKey(data.params.unstakingAddress);\n\n        const allocateAccount = SystemProgram.allocate({\n          accountPubkey: unstakingAddress,\n          space: StakeProgram.space,\n        });\n        tx.add(allocateAccount);\n\n        const assignAccount = SystemProgram.assign({\n          accountPubkey: unstakingAddress,\n          programId: StakeProgram.programId,\n        });\n        tx.add(assignAccount);\n\n        const splitStake = StakeProgram.split(\n          {\n            stakePubkey: new PublicKey(stakingAddress),\n            authorizedPubkey: new PublicKey(fromAddress),\n            splitStakePubkey: unstakingAddress,\n            lamports: new BigNumber(data.params.amount).toNumber(),\n          },\n          0\n        );\n        tx.add(splitStake.instructions[1]);\n\n        const deactivateStaking = StakeProgram.deactivate({\n          stakePubkey: unstakingAddress,\n          authorizedPubkey: new PublicKey(fromAddress),\n        });\n        tx.add(deactivateStaking);\n\n        return tx.instructions;\n      } else {\n        const deactivateStaking = StakeProgram.deactivate({\n          stakePubkey: new PublicKey(stakingAddress),\n          authorizedPubkey: new PublicKey(fromAddress),\n        });\n\n        return deactivateStaking.instructions;\n      }\n    }\n\n    default: {\n      const unreachable: never = stakingType;\n      throw new Error(`Unknown staking type ${unreachable}`);\n    }\n  }\n}\n\n/**\n * Construct Staking Withdraw Solana instructions\n *\n * @param {StakingWithdraw} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Staking Withdraw  Solana instructions\n */\nfunction stakingWithdrawInstruction(data: StakingWithdraw): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, amount },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(amount, 'Missing amount param');\n\n  const withdrawStaking = StakeProgram.withdraw({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(fromAddress),\n    toPubkey: new PublicKey(fromAddress),\n    lamports: new BigNumber(amount).toNumber(),\n  });\n\n  return withdrawStaking.instructions;\n}\n\n/**\n * Construct an idempotent Create Associated Token Account instruction.\n *\n * Uses createAssociatedTokenAccountIdempotentInstruction so the instruction is a\n * no-op when the ATA already exists (discriminator byte = 1), instead of failing\n * like the legacy createAssociatedTokenAccountInstruction (empty data).\n *\n * @param {AtaInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing the Create ATA instruction\n */\nfunction createATAInstruction(data: AtaInit): TransactionInstruction[] {\n  const {\n    params: { mintAddress, ataAddress, ownerAddress, payerAddress, programId },\n  } = data;\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(ataAddress, 'Missing ataAddress param');\n  assert(ownerAddress, 'Missing ownerAddress param');\n  assert(payerAddress, 'Missing payerAddress param');\n\n  let associatedTokenAccountInstruction: TransactionInstruction;\n  if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {\n    associatedTokenAccountInstruction = createAssociatedTokenAccountIdempotentInstruction(\n      new PublicKey(payerAddress),\n      new PublicKey(ataAddress),\n      new PublicKey(ownerAddress),\n      new PublicKey(mintAddress),\n      TOKEN_2022_PROGRAM_ID\n    );\n  } else {\n    associatedTokenAccountInstruction = createAssociatedTokenAccountIdempotentInstruction(\n      new PublicKey(payerAddress),\n      new PublicKey(ataAddress),\n      new PublicKey(ownerAddress),\n      new PublicKey(mintAddress)\n    );\n  }\n  return [associatedTokenAccountInstruction];\n}\n\n/**\n * Construct a Token-2022 Reallocate instruction that adds the ConfidentialTransferAccount\n * extension. ConfigureAccount fails on-chain unless the account already holds the extension,\n * and an ATA is created without it — so CT enablement must run this before ConfigureAccount.\n *\n * @param {ReallocateConfidentialTransferAccount} data - the data to build the instruction\n * @returns {TransactionInstruction[]} the Reallocate instruction\n */\nfunction reallocateConfidentialTransferAccountInstruction(\n  data: ReallocateConfidentialTransferAccount\n): TransactionInstruction[] {\n  const {\n    params: { tokenAddress, payerAddress, ownerAddress, programId },\n  } = data;\n  assert(tokenAddress, 'Missing tokenAddress param');\n  assert(payerAddress, 'Missing payerAddress param');\n  assert(ownerAddress, 'Missing ownerAddress param');\n  assert(programId && programId === TOKEN_2022_PROGRAM_ID.toString(), 'Reallocate requires the Token-2022 program');\n\n  return [\n    createReallocateInstruction(\n      new PublicKey(tokenAddress),\n      new PublicKey(payerAddress),\n      [ExtensionType.ConfidentialTransferAccount],\n      new PublicKey(ownerAddress),\n      [],\n      TOKEN_2022_PROGRAM_ID\n    ),\n  ];\n}\n\n/**\n * Construct Close ATA Solana instructions\n *\n * @param {WalletInit} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Close ATA Solana instruction\n */\nfunction closeATAInstruction(data: AtaClose): TransactionInstruction[] {\n  const {\n    params: { accountAddress, destinationAddress, authorityAddress, programId },\n  } = data;\n  assert(accountAddress, 'Missing accountAddress param');\n  assert(destinationAddress, 'Missing destinationAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n\n  const tokenProgramId = programId ? new PublicKey(programId) : TOKEN_PROGRAM_ID;\n  const closeAssociatedTokenAccountInstruction = createCloseAccountInstruction(\n    new PublicKey(accountAddress),\n    new PublicKey(destinationAddress),\n    new PublicKey(authorityAddress),\n    [],\n    tokenProgramId\n  );\n  return [closeAssociatedTokenAccountInstruction];\n}\n\n/**\n * Construct RecoverNested ATA Solana instruction\n *\n * Recovers tokens from a nested ATA (an ATA whose owner is another ATA rather than a wallet address).\n * This uses the Associated Token Account program's RecoverNested instruction, which allows the root\n * wallet owner to sign and recover tokens without needing the intermediate ATA to sign.\n *\n * @param {AtaRecoverNested} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing the RecoverNested instruction\n */\nfunction recoverNestedATAInstruction(data: AtaRecoverNested): TransactionInstruction[] {\n  const {\n    params: {\n      nestedAccountAddress,\n      nestedMintAddress,\n      destinationAccountAddress,\n      ownerAccountAddress,\n      ownerMintAddress,\n      walletAddress,\n    },\n  } = data;\n  assert(nestedAccountAddress, 'Missing nestedAccountAddress param');\n  assert(nestedMintAddress, 'Missing nestedMintAddress param');\n  assert(destinationAccountAddress, 'Missing destinationAccountAddress param');\n  assert(ownerAccountAddress, 'Missing ownerAccountAddress param');\n  assert(ownerMintAddress, 'Missing ownerMintAddress param');\n  assert(walletAddress, 'Missing walletAddress param');\n\n  const recoverNestedInstruction = createRecoverNestedInstruction(\n    new PublicKey(nestedAccountAddress),\n    new PublicKey(nestedMintAddress),\n    new PublicKey(destinationAccountAddress),\n    new PublicKey(ownerAccountAddress),\n    new PublicKey(ownerMintAddress),\n    new PublicKey(walletAddress)\n  );\n  return [recoverNestedInstruction];\n}\n\n/**\n * Construct Staking Account Authorize Solana instructions\n *\n * @param {StakingAuthorize} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Staking Account Authorize instructions\n */\nfunction stakingAuthorizeInstruction(data: StakingAuthorize): TransactionInstruction[] {\n  const {\n    params: { stakingAddress, oldAuthorizeAddress, newAuthorizeAddress, newWithdrawAddress },\n  } = data;\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(oldAuthorizeAddress, 'Missing oldAuthorizeAddress param');\n  assert(newAuthorizeAddress, 'Missing newAuthorizeAddress param');\n  assert(newWithdrawAddress, 'Missing newWithdrawAddress param');\n\n  const tx = new Transaction();\n\n  const authorizeStaking = StakeProgram.authorize({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(oldAuthorizeAddress),\n    newAuthorizedPubkey: new PublicKey(newAuthorizeAddress),\n    stakeAuthorizationType: StakeAuthorizationLayout.Staker,\n  });\n\n  const authorizeWithdraw = StakeProgram.authorize({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(oldAuthorizeAddress),\n    newAuthorizedPubkey: new PublicKey(newAuthorizeAddress),\n    stakeAuthorizationType: StakeAuthorizationLayout.Withdrawer,\n    custodianPubkey: new PublicKey(newWithdrawAddress),\n  });\n  tx.add(authorizeStaking);\n  tx.add(authorizeWithdraw);\n\n  return tx.instructions;\n}\n\n/**\n * Construct Delegate Solana instructions\n *\n * @param {StakingActivate} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Delegate Solana instructions\n */\nfunction stakingDelegateInstruction(data: StakingDelegate): TransactionInstruction[] {\n  const {\n    params: { fromAddress, stakingAddress, validator },\n  } = data;\n  assert(fromAddress, 'Missing fromAddress param');\n  assert(stakingAddress, 'Missing stakingAddress param');\n  assert(validator, 'Missing validator param');\n  const tx = new Transaction();\n  const delegateStaking = StakeProgram.delegate({\n    stakePubkey: new PublicKey(stakingAddress),\n    authorizedPubkey: new PublicKey(fromAddress),\n    votePubkey: new PublicKey(validator),\n  });\n  tx.add(delegateStaking);\n\n  return tx.instructions;\n}\n\n/**\n * Construct MintTo Solana instructions\n *\n * @param {MintTo} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing MintTo Solana instructions\n */\nfunction mintToInstruction(data: MintTo): TransactionInstruction[] {\n  const {\n    params: { mintAddress, destinationAddress, authorityAddress, amount, programId },\n  } = data;\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(destinationAddress, 'Missing destinationAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assert(amount, 'Missing amount param');\n\n  const mint = new PublicKey(mintAddress);\n  const destination = new PublicKey(destinationAddress);\n  const authority = new PublicKey(authorityAddress);\n\n  let mintToInstr: TransactionInstruction;\n  if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {\n    mintToInstr = createMintToInstruction(mint, destination, authority, BigInt(amount), [], TOKEN_2022_PROGRAM_ID);\n  } else {\n    mintToInstr = createMintToInstruction(mint, destination, authority, BigInt(amount));\n  }\n\n  return [mintToInstr];\n}\n\n/**\n * Construct Burn Solana instructions\n *\n * @param {Burn} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing Burn Solana instructions\n */\nfunction burnInstruction(data: Burn): TransactionInstruction[] {\n  const {\n    params: { mintAddress, accountAddress, authorityAddress, amount, programId },\n  } = data;\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(accountAddress, 'Missing accountAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assert(amount, 'Missing amount param');\n\n  const mint = new PublicKey(mintAddress);\n  const account = new PublicKey(accountAddress);\n  const authority = new PublicKey(authorityAddress);\n\n  let burnInstr: TransactionInstruction;\n  if (programId && programId === TOKEN_2022_PROGRAM_ID.toString()) {\n    burnInstr = createBurnInstruction(account, mint, authority, BigInt(amount), [], TOKEN_2022_PROGRAM_ID);\n  } else {\n    burnInstr = createBurnInstruction(account, mint, authority, BigInt(amount));\n  }\n\n  return [burnInstr];\n}\n\n/**\n * Process custom instruction - converts to TransactionInstruction\n * Handles conversion from string-based format to TransactionInstruction format\n *\n * @param {CustomInstruction} data - the data containing the custom instruction\n * @returns {TransactionInstruction[]} An array containing the custom instruction\n */\nfunction customInstruction(data: InstructionParams): TransactionInstruction[] {\n  const { params } = data as CustomInstruction;\n  assert(params.programId, 'Missing programId in custom instruction');\n  assert(params.keys && Array.isArray(params.keys), 'Missing or invalid keys in custom instruction');\n  assert(params.data !== undefined, 'Missing data in custom instruction');\n\n  // Convert string data to Buffer\n  let dataBuffer: Buffer;\n\n  if (isValidBase64(params.data)) {\n    dataBuffer = Buffer.from(params.data, 'base64');\n  } else if (isValidHex(params.data)) {\n    dataBuffer = Buffer.from(params.data, 'hex');\n  } else {\n    // Fallback to UTF-8\n    dataBuffer = Buffer.from(params.data, 'utf8');\n  }\n\n  // Create a new TransactionInstruction with the converted data\n  const convertedInstruction = new TransactionInstruction({\n    programId: new PublicKey(params.programId),\n    keys: params.keys.map((key) => ({\n      pubkey: new PublicKey(key.pubkey),\n      isSigner: key.isSigner,\n      isWritable: key.isWritable,\n    })),\n    data: dataBuffer,\n  });\n\n  return [convertedInstruction];\n}\n\n/**\n * Construct the sRFC-37 Token ACL `ThawPermissionlessIdempotent` instruction.\n *\n * The first nine accounts are fixed (authority, mint, tokenAccount, flagAccount, tokenAccountOwner,\n * mintConfig, tokenProgram, systemProgram, gatingProgram) in that exact order and with the flags the\n * program expects. Any gating-program extra accounts (resolved live by the caller) are appended\n * afterwards. The instruction data is the single discriminator byte.\n *\n * @param {PermissionlessThawIdempotent} data - the data to build the instruction\n * @returns {TransactionInstruction[]} An array containing the permissionless thaw instruction\n */\nfunction permissionlessThawIdempotentInstruction(data: PermissionlessThawIdempotent): TransactionInstruction[] {\n  const {\n    params: { authority, mint, tokenAccount, tokenAccountOwner, gatingProgram, flagAccount, mintConfig, extraAccounts },\n  } = data;\n  assert(authority, 'Missing authority param');\n  assert(mint, 'Missing mint param');\n  assert(tokenAccount, 'Missing tokenAccount param');\n  assert(tokenAccountOwner, 'Missing tokenAccountOwner param');\n  assert(gatingProgram, 'Missing gatingProgram param');\n  assert(flagAccount, 'Missing flagAccount param');\n  assert(mintConfig, 'Missing mintConfig param');\n\n  const tokenProgram = data.params.tokenProgram ?? TOKEN_2022_PROGRAM_ID.toString();\n  const systemProgram = data.params.systemProgram ?? SystemProgram.programId.toString();\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(authority), isSigner: true, isWritable: false },\n    { pubkey: new PublicKey(mint), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(tokenAccount), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(flagAccount), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(tokenAccountOwner), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(mintConfig), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(tokenProgram), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(systemProgram), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(gatingProgram), isSigner: false, isWritable: false },\n    ...(extraAccounts ?? []).map((meta) => ({\n      pubkey: new PublicKey(meta.pubkey),\n      isSigner: meta.isSigner,\n      isWritable: meta.isWritable,\n    })),\n  ];\n\n  const thawInstruction = new TransactionInstruction({\n    keys,\n    programId: new PublicKey(TOKEN_ACL_PROGRAM_ID),\n    data: Buffer.from([THAW_PERMISSIONLESS_IDEMPOTENT_DISCRIMINATOR]),\n  });\n  return [thawInstruction];\n}\n\nfunction upsertAccountMeta(keys: AccountMeta[], meta: AccountMeta): void {\n  const existing = keys.find((account) => account.pubkey.equals(meta.pubkey));\n  if (existing) {\n    existing.isWritable = existing.isWritable || meta.isWritable;\n    existing.isSigner = existing.isSigner || meta.isSigner;\n  } else {\n    keys.push(meta);\n  }\n}\n\nfunction buildTransferHookAccountMetas(extraAccountMetas: ExtraAccountMeta[]): AccountMeta[] {\n  return extraAccountMetas.map((meta) => ({\n    pubkey: new PublicKey(meta.pubkey),\n    isSigner: meta.isSigner,\n    isWritable: meta.isWritable,\n  }));\n}\n\nfunction addTransferHookAccounts(instruction: TransactionInstruction, extraAccountMetas: ExtraAccountMeta[]): void {\n  const extraMetas = buildTransferHookAccountMetas(extraAccountMetas);\n  for (const meta of extraMetas) {\n    upsertAccountMeta(instruction.keys, meta);\n  }\n}\n\n// ─── Confidential Transfer instruction builders ────────────────────────────\n//\n// All layouts verified against canonical Rust source:\n// solana-program/token-2022 `interface/src/extension/confidential_transfer/instruction.rs`\n//\n// Instruction builders are v0/v1-agnostic: they produce instruction data and\n// account metas only. The caller (Wallet Platform) assembles them into v1\n// transactions in the correct order.\n\n// Token-2022 CT sub-instruction discriminators (byte 1 after CT_EXT_DISCRIMINATOR)\nconst CT_CONFIGURE_ACCOUNT_DISCRIMINATOR = 2;\nconst CT_DEPOSIT_DISCRIMINATOR = 5;\nconst CT_WITHDRAW_DISCRIMINATOR = 6;\nconst CT_TRANSFER_DISCRIMINATOR = 7;\nconst CT_APPLY_PENDING_BALANCE_DISCRIMINATOR = 8;\n\n// zk-elgamal-proof instruction discriminators\nconst PROOF_VERIFY_PUBKEY_VALIDITY = 4;\nconst PROOF_VERIFY_EQUALITY = 3;\nconst PROOF_VERIFY_VALIDITY_3HANDLES = 12;\nconst PROOF_VERIFY_RANGE_U128 = 7;\n\n/**\n * Validates that a string can be safely converted to BigInt.\n * Accepts non-negative integer strings (e.g. \"1000000\", \"0\").\n * Also rejects values that would overflow u64 (2^64 - 1).\n */\nfunction assertValidAmountString(value: string, fieldName: string): void {\n  assert(value, `Missing ${fieldName} param`);\n  if (!/^\\d+$/.test(value)) {\n    throw new Error(`Invalid ${fieldName}: expected non-negative integer string, got \"${value}\"`);\n  }\n  if (BigInt(value) > 0xffffffffffffffffn) {\n    throw new Error(`Invalid ${fieldName}: value exceeds u64 max (18446744073709551615), got \"${value}\"`);\n  }\n}\n\n/**\n * Validates that a number fits in a u8 (0-255).\n */\nfunction assertValidU8(value: number, fieldName: string): void {\n  if (!Number.isInteger(value) || value < 0 || value > 255) {\n    throw new Error(`Invalid ${fieldName}: expected u8 (0-255), got ${value}`);\n  }\n}\n\n/**\n * Validates that a number fits in a signed i8 (-128 to 127).\n */\nfunction assertValidI8(value: number, fieldName: string): void {\n  if (!Number.isInteger(value) || value < -128 || value > 127) {\n    throw new Error(`Invalid ${fieldName}: expected i8 (-128 to 127), got ${value}`);\n  }\n}\n\n// Buffer layouts for CT instructions with multi-byte fields\nconst configureAccountDataLayout = struct<{\n  instruction: number;\n  confidentialTransferInstruction: number;\n  elgamalPubkey: Uint8Array;\n  decryptableZeroBalance: Uint8Array;\n  maximumPendingBalanceCreditCounter: Uint8Array;\n  proofInstructionOffset: number;\n}>([\n  u8('instruction'), // 27\n  u8('confidentialTransferInstruction'), // 2\n  blob(32, 'elgamalPubkey'), // new_account_elgamal_pubkey\n  blob(36, 'decryptableZeroBalance'),\n  blob(8, 'maximumPendingBalanceCreditCounter'),\n  s8('proofInstructionOffset'), // i8 — signed: negative = proof is before this instruction\n]); // span = 79\n\nconst applyPendingBalanceDataLayout = struct<{\n  instruction: number;\n  confidentialTransferInstruction: number;\n  expectedPendingBalanceCreditCounter: Uint8Array;\n  newDecryptableAvailableBalance: Uint8Array;\n}>([\n  u8('instruction'), // 27\n  u8('confidentialTransferInstruction'), // 8\n  blob(8, 'expectedPendingBalanceCreditCounter'),\n  blob(36, 'newDecryptableAvailableBalance'),\n]); // span = 46\n\nconst withdrawDataLayout = struct<{\n  instruction: number;\n  confidentialTransferInstruction: number;\n  amount: Uint8Array;\n  decimals: number;\n  newDecryptableAvailableBalance: Uint8Array;\n  equalityProofInstructionOffset: number;\n  rangeProofInstructionOffset: number;\n}>([\n  u8('instruction'), // 27\n  u8('confidentialTransferInstruction'), // 6\n  blob(8, 'amount'),\n  u8('decimals'),\n  blob(36, 'newDecryptableAvailableBalance'),\n  s8('equalityProofInstructionOffset'), // i8\n  s8('rangeProofInstructionOffset'), // i8\n]); // span = 49\n\nconst transferDataLayout = struct<{\n  instruction: number;\n  confidentialTransferInstruction: number;\n  newSourceDecryptableAvailableBalance: Uint8Array;\n  transferAmountAuditorCiphertextLo: Uint8Array;\n  transferAmountAuditorCiphertextHi: Uint8Array;\n  equalityProofInstructionOffset: number;\n  ciphertextValidityProofInstructionOffset: number;\n  rangeProofInstructionOffset: number;\n}>([\n  u8('instruction'), // 27\n  u8('confidentialTransferInstruction'), // 7\n  blob(36, 'newSourceDecryptableAvailableBalance'),\n  blob(64, 'transferAmountAuditorCiphertextLo'),\n  blob(64, 'transferAmountAuditorCiphertextHi'),\n  s8('equalityProofInstructionOffset'), // i8\n  s8('ciphertextValidityProofInstructionOffset'), // i8\n  s8('rangeProofInstructionOffset'), // i8\n]); // span = 169\n\n/**\n * Build a ConfigureAccount instruction for Token-2022 confidential transfers.\n *\n * Registers an ElGamal pubkey + AES zero ciphertext on a token account so it\n * can send and receive confidential transfers. Must be accompanied by a\n * VerifyPubkeyValidity proof instruction (inline or context state).\n */\nfunction configureConfidentialTransferAccountInstruction(\n  data: ConfigureConfidentialTransferAccount\n): TransactionInstruction[] {\n  const {\n    params: {\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      elgamalPubkey,\n      instructionsSysvarOrContextStateAddress,\n      decryptableZeroBalance,\n      maximumPendingBalanceCreditCounter,\n      proofInstructionOffset,\n    },\n  } = data;\n  assert(tokenAddress, 'Missing tokenAddress param');\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assert(elgamalPubkey, 'Missing elgamalPubkey param');\n  assert(decryptableZeroBalance, 'Missing decryptableZeroBalance param');\n  assertValidAmountString(maximumPendingBalanceCreditCounter, 'maximumPendingBalanceCreditCounter');\n  assertValidI8(proofInstructionOffset, 'proofInstructionOffset');\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },\n    {\n      pubkey: new PublicKey(instructionsSysvarOrContextStateAddress || INSTRUCTIONS_SYSVAR_ADDRESS),\n      isSigner: false,\n      isWritable: false,\n    },\n    { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },\n  ];\n\n  const decryptableBytes = Buffer.from(decryptableZeroBalance, 'hex');\n  assert(decryptableBytes.length === 36, 'decryptableZeroBalance must be 36 bytes');\n  const elgamalPubkeyBytes = Buffer.from(elgamalPubkey, 'hex');\n  assert(elgamalPubkeyBytes.length === 32, 'elgamalPubkey must be 32 bytes');\n\n  const dataBuffer = Buffer.alloc(configureAccountDataLayout.span);\n  const counterBuffer = Buffer.alloc(8);\n  counterBuffer.writeBigUInt64LE(BigInt(maximumPendingBalanceCreditCounter));\n\n  configureAccountDataLayout.encode(\n    {\n      instruction: CT_EXT_DISCRIMINATOR,\n      confidentialTransferInstruction: CT_CONFIGURE_ACCOUNT_DISCRIMINATOR,\n      elgamalPubkey: elgamalPubkeyBytes,\n      decryptableZeroBalance: decryptableBytes,\n      maximumPendingBalanceCreditCounter: counterBuffer,\n      proofInstructionOffset,\n    },\n    dataBuffer\n  );\n\n  return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];\n}\n\n/**\n * Build an ApplyPendingBalance instruction.\n *\n * Credits pending balance into available balance. Idempotent — no-op if 0\n * pending. In v1 transactions, always instruction #1.\n */\nfunction applyPendingBalanceInstruction(data: ApplyPendingBalance): TransactionInstruction[] {\n  const {\n    params: { tokenAddress, authorityAddress, expectedPendingBalanceCreditCounter, newDecryptableAvailableBalance },\n  } = data;\n  assert(tokenAddress, 'Missing tokenAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assertValidAmountString(expectedPendingBalanceCreditCounter, 'expectedPendingBalanceCreditCounter');\n  assert(newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },\n  ];\n\n  const decryptableBytes = Buffer.from(newDecryptableAvailableBalance, 'hex');\n  assert(decryptableBytes.length === 36, 'newDecryptableAvailableBalance must be 36 bytes');\n\n  const dataBuffer = Buffer.alloc(applyPendingBalanceDataLayout.span);\n  const counterBuffer = Buffer.alloc(8);\n  counterBuffer.writeBigUInt64LE(BigInt(expectedPendingBalanceCreditCounter));\n\n  applyPendingBalanceDataLayout.encode(\n    {\n      instruction: CT_EXT_DISCRIMINATOR,\n      confidentialTransferInstruction: CT_APPLY_PENDING_BALANCE_DISCRIMINATOR,\n      expectedPendingBalanceCreditCounter: counterBuffer,\n      newDecryptableAvailableBalance: decryptableBytes,\n    },\n    dataBuffer\n  );\n\n  return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];\n}\n\n/**\n * Build a Deposit instruction (public → confidential conversion).\n *\n * Moves public SPL token balance into confidential pending balance.\n * No proof required — the amount is public.\n */\nfunction confidentialDepositInstruction(data: ConfidentialDeposit): TransactionInstruction[] {\n  const {\n    params: { tokenAddress, mintAddress, authorityAddress, amount, decimals },\n  } = data;\n  assert(tokenAddress, 'Missing tokenAddress param');\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assertValidAmountString(amount, 'amount');\n  assertValidU8(decimals, 'decimals');\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false },\n  ];\n\n  // Layout: [27][5] + amount(u64) + decimals(u8) = 11 bytes\n  const dataBuffer = Buffer.alloc(11);\n  dataBuffer.writeUInt8(CT_EXT_DISCRIMINATOR, 0);\n  dataBuffer.writeUInt8(CT_DEPOSIT_DISCRIMINATOR, 1);\n  dataBuffer.writeBigUInt64LE(BigInt(amount), 2);\n  dataBuffer.writeUInt8(decimals, 10);\n\n  return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];\n}\n\n/**\n * Build a Withdraw instruction (confidential → public conversion).\n *\n * Requires equality + range proof verification (inline or context state).\n */\nfunction confidentialWithdrawInstruction(data: ConfidentialWithdraw): TransactionInstruction[] {\n  const {\n    params: {\n      tokenAddress,\n      mintAddress,\n      authorityAddress,\n      instructionsSysvarAddress,\n      equalityProofContextStateAddress,\n      rangeProofContextStateAddress,\n      amount,\n      decimals,\n      newDecryptableAvailableBalance,\n      equalityProofInstructionOffset,\n      rangeProofInstructionOffset,\n    },\n  } = data;\n  assert(tokenAddress, 'Missing tokenAddress param');\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assertValidAmountString(amount, 'amount');\n  assertValidU8(decimals, 'decimals');\n  assertValidI8(equalityProofInstructionOffset, 'equalityProofInstructionOffset');\n  assertValidI8(rangeProofInstructionOffset, 'rangeProofInstructionOffset');\n  assert(newDecryptableAvailableBalance, 'Missing newDecryptableAvailableBalance param');\n\n  // Assert context state addresses are provided when offset == 0 (context state mode)\n  if (equalityProofInstructionOffset === 0) {\n    assert(\n      equalityProofContextStateAddress,\n      'equalityProofContextStateAddress is required when equalityProofInstructionOffset is 0 (context state mode)'\n    );\n  }\n  if (rangeProofInstructionOffset === 0) {\n    assert(\n      rangeProofContextStateAddress,\n      'rangeProofContextStateAddress is required when rangeProofInstructionOffset is 0 (context state mode)'\n    );\n  }\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(tokenAddress), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },\n  ];\n\n  // Add instructions sysvar if any proof is inline (offset != 0)\n  const hasInlineProof = equalityProofInstructionOffset !== 0 || rangeProofInstructionOffset !== 0;\n  if (hasInlineProof || instructionsSysvarAddress) {\n    keys.push({\n      pubkey: new PublicKey(instructionsSysvarAddress || INSTRUCTIONS_SYSVAR_ADDRESS),\n      isSigner: false,\n      isWritable: false,\n    });\n  }\n\n  // Add context state accounts for pre-verified proofs (offset == 0)\n  if (equalityProofInstructionOffset === 0 && equalityProofContextStateAddress) {\n    keys.push({ pubkey: new PublicKey(equalityProofContextStateAddress), isSigner: false, isWritable: false });\n  }\n  if (rangeProofInstructionOffset === 0 && rangeProofContextStateAddress) {\n    keys.push({ pubkey: new PublicKey(rangeProofContextStateAddress), isSigner: false, isWritable: false });\n  }\n\n  keys.push({ pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false });\n\n  const decryptableBytes = Buffer.from(newDecryptableAvailableBalance, 'hex');\n  assert(decryptableBytes.length === 36, 'newDecryptableAvailableBalance must be 36 bytes');\n\n  const dataBuffer = Buffer.alloc(withdrawDataLayout.span);\n  const amountBuffer = Buffer.alloc(8);\n  amountBuffer.writeBigUInt64LE(BigInt(amount));\n\n  withdrawDataLayout.encode(\n    {\n      instruction: CT_EXT_DISCRIMINATOR,\n      confidentialTransferInstruction: CT_WITHDRAW_DISCRIMINATOR,\n      amount: amountBuffer,\n      decimals,\n      newDecryptableAvailableBalance: decryptableBytes,\n      equalityProofInstructionOffset,\n      rangeProofInstructionOffset,\n    },\n    dataBuffer\n  );\n\n  return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];\n}\n\n/**\n * Build a confidential Transfer instruction.\n *\n * Requires equality + ciphertext validity + range proof verification (inline or context state).\n */\nfunction confidentialTransferInstruction(data: ConfidentialTransfer): TransactionInstruction[] {\n  const {\n    params: {\n      sourceTokenAddress,\n      mintAddress,\n      destinationTokenAddress,\n      authorityAddress,\n      instructionsSysvarAddress,\n      equalityProofContextStateAddress,\n      ciphertextValidityProofContextStateAddress,\n      rangeProofContextStateAddress,\n      newSourceDecryptableAvailableBalance,\n      transferAmountAuditorCiphertextLo,\n      transferAmountAuditorCiphertextHi,\n      equalityProofInstructionOffset,\n      ciphertextValidityProofInstructionOffset,\n      rangeProofInstructionOffset,\n    },\n  } = data;\n  assert(sourceTokenAddress, 'Missing sourceTokenAddress param');\n  assert(mintAddress, 'Missing mintAddress param');\n  assert(destinationTokenAddress, 'Missing destinationTokenAddress param');\n  assert(authorityAddress, 'Missing authorityAddress param');\n  assert(newSourceDecryptableAvailableBalance, 'Missing newSourceDecryptableAvailableBalance param');\n  assert(transferAmountAuditorCiphertextLo, 'Missing transferAmountAuditorCiphertextLo param');\n  assert(transferAmountAuditorCiphertextHi, 'Missing transferAmountAuditorCiphertextHi param');\n  assertValidI8(equalityProofInstructionOffset, 'equalityProofInstructionOffset');\n  assertValidI8(ciphertextValidityProofInstructionOffset, 'ciphertextValidityProofInstructionOffset');\n  assertValidI8(rangeProofInstructionOffset, 'rangeProofInstructionOffset');\n\n  // Assert context state addresses are provided when offset == 0 (context state mode)\n  if (equalityProofInstructionOffset === 0) {\n    assert(\n      equalityProofContextStateAddress,\n      'equalityProofContextStateAddress is required when equalityProofInstructionOffset is 0 (context state mode)'\n    );\n  }\n  if (ciphertextValidityProofInstructionOffset === 0) {\n    assert(\n      ciphertextValidityProofContextStateAddress,\n      'ciphertextValidityProofContextStateAddress is required when ciphertextValidityProofInstructionOffset is 0 (context state mode)'\n    );\n  }\n  if (rangeProofInstructionOffset === 0) {\n    assert(\n      rangeProofContextStateAddress,\n      'rangeProofContextStateAddress is required when rangeProofInstructionOffset is 0 (context state mode)'\n    );\n  }\n\n  const keys: AccountMeta[] = [\n    { pubkey: new PublicKey(sourceTokenAddress), isSigner: false, isWritable: true },\n    { pubkey: new PublicKey(mintAddress), isSigner: false, isWritable: false },\n    { pubkey: new PublicKey(destinationTokenAddress), isSigner: false, isWritable: true },\n  ];\n\n  // Add instructions sysvar if any proof is inline (offset != 0)\n  const hasInlineProof =\n    equalityProofInstructionOffset !== 0 ||\n    ciphertextValidityProofInstructionOffset !== 0 ||\n    rangeProofInstructionOffset !== 0;\n  if (hasInlineProof || instructionsSysvarAddress) {\n    keys.push({\n      pubkey: new PublicKey(instructionsSysvarAddress || INSTRUCTIONS_SYSVAR_ADDRESS),\n      isSigner: false,\n      isWritable: false,\n    });\n  }\n\n  // Add context state accounts for pre-verified proofs (offset == 0)\n  if (equalityProofInstructionOffset === 0 && equalityProofContextStateAddress) {\n    keys.push({ pubkey: new PublicKey(equalityProofContextStateAddress), isSigner: false, isWritable: false });\n  }\n  if (ciphertextValidityProofInstructionOffset === 0 && ciphertextValidityProofContextStateAddress) {\n    keys.push({\n      pubkey: new PublicKey(ciphertextValidityProofContextStateAddress),\n      isSigner: false,\n      isWritable: false,\n    });\n  }\n  if (rangeProofInstructionOffset === 0 && rangeProofContextStateAddress) {\n    keys.push({ pubkey: new PublicKey(rangeProofContextStateAddress), isSigner: false, isWritable: false });\n  }\n\n  keys.push({ pubkey: new PublicKey(authorityAddress), isSigner: true, isWritable: false });\n\n  const decryptableBytes = Buffer.from(newSourceDecryptableAvailableBalance, 'hex');\n  assert(decryptableBytes.length === 36, 'newSourceDecryptableAvailableBalance must be 36 bytes');\n  const auditorLoBytes = Buffer.from(transferAmountAuditorCiphertextLo, 'hex');\n  assert(auditorLoBytes.length === 64, 'transferAmountAuditorCiphertextLo must be 64 bytes');\n  const auditorHiBytes = Buffer.from(transferAmountAuditorCiphertextHi, 'hex');\n  assert(auditorHiBytes.length === 64, 'transferAmountAuditorCiphertextHi must be 64 bytes');\n\n  const dataBuffer = Buffer.alloc(transferDataLayout.span);\n\n  transferDataLayout.encode(\n    {\n      instruction: CT_EXT_DISCRIMINATOR,\n      confidentialTransferInstruction: CT_TRANSFER_DISCRIMINATOR,\n      newSourceDecryptableAvailableBalance: decryptableBytes,\n      transferAmountAuditorCiphertextLo: auditorLoBytes,\n      transferAmountAuditorCiphertextHi: auditorHiBytes,\n      equalityProofInstructionOffset,\n      ciphertextValidityProofInstructionOffset,\n      rangeProofInstructionOffset,\n    },\n    dataBuffer\n  );\n\n  return [new TransactionInstruction({ keys, programId: TOKEN_2022_PROGRAM_ID, data: dataBuffer })];\n}\n\n// ─── zk-elgamal-proof verification instruction builders ────────────────────\n\n/**\n * Build a VerifyPubkeyValidity proof instruction.\n *\n * Used with ConfigureAccount to prove knowledge of the ElGamal secret key.\n * Discriminator: [4]\n */\nfunction verifyPubkeyValidityInstruction(\n  data: VerifyPubkeyValidity,\n  zkProofProgramId?: string\n): TransactionInstruction[] {\n  const {\n    params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress },\n  } = data;\n\n  const keys: AccountMeta[] = [];\n  if (contextStateAccountAddress && contextStateAuthorityAddress) {\n    keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });\n    keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });\n  }\n\n  // Use buildProofDataOrOffsetBuffer to support both inline proof and context state offset\n  const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_PUBKEY_VALIDITY, proofData, undefined, true);\n  return [\n    new TransactionInstruction({\n      keys,\n      programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),\n      data: dataBuffer,\n    }),\n  ];\n}\n\n/**\n * Build a VerifyCiphertextCommitmentEquality proof instruction.\n *\n * Used with Transfer and Withdraw. Discriminator: [3]\n */\nfunction verifyEqualityProofInstruction(\n  data: VerifyEqualityProof,\n  zkProofProgramId?: string\n): TransactionInstruction[] {\n  const {\n    params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset },\n  } = data;\n\n  const keys: AccountMeta[] = [];\n  if (contextStateAccountAddress && contextStateAuthorityAddress) {\n    keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });\n    keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });\n  }\n\n  const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_EQUALITY, proofData, offset, true);\n  return [\n    new TransactionInstruction({\n      keys,\n      programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),\n      data: dataBuffer,\n    }),\n  ];\n}\n\n/**\n * Build a VerifyBatchedGroupedCiphertext3HandlesValidity proof instruction.\n *\n * Used with Transfer. Discriminator: [12]\n */\nfunction verifyValidityProofInstruction(\n  data: VerifyValidityProof,\n  zkProofProgramId?: string\n): TransactionInstruction[] {\n  const {\n    params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset },\n  } = data;\n\n  const keys: AccountMeta[] = [];\n  if (contextStateAccountAddress && contextStateAuthorityAddress) {\n    keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });\n    keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });\n  }\n\n  const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_VALIDITY_3HANDLES, proofData, offset, true);\n  return [\n    new TransactionInstruction({\n      keys,\n      programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),\n      data: dataBuffer,\n    }),\n  ];\n}\n\n/**\n * Build a VerifyBatchedRangeProofU128 proof instruction.\n *\n * Used with Transfer. Discriminator: [7]\n * Note: range proofs do not use a context state account in the same way as\n * equality/validity proofs — the proof is either inline or read from a\n * record account at the given offset.\n */\nfunction verifyRangeProofInstruction(data: VerifyRangeProof, zkProofProgramId?: string): TransactionInstruction[] {\n  const {\n    params: { proofData, contextStateAccountAddress, contextStateAuthorityAddress, offset },\n  } = data;\n\n  const keys: AccountMeta[] = [];\n  if (contextStateAccountAddress && contextStateAuthorityAddress) {\n    keys.push({ pubkey: new PublicKey(contextStateAccountAddress), isSigner: false, isWritable: true });\n    keys.push({ pubkey: new PublicKey(contextStateAuthorityAddress), isSigner: false, isWritable: false });\n  }\n\n  const dataBuffer = buildProofDataOrOffsetBuffer(PROOF_VERIFY_RANGE_U128, proofData, offset, false);\n  return [\n    new TransactionInstruction({\n      keys,\n      programId: new PublicKey(zkProofProgramId || ZK_ELGAMAL_PROOF_PROGRAM_ID),\n      data: dataBuffer,\n    }),\n  ];\n}\n\n/**\n * Build proof instruction data from either inline proof bytes or a context\n * state account offset.\n *\n * If proofData is provided: [discriminator: u8] + [proof_data: variable]\n * If offset is provided: [discriminator: u8] + [offset: u32 LE]\n *\n * @param useUInt32 - true for equality/validity (writeUInt32LE), false for range (writeInt32LE)\n */\nfunction buildProofDataOrOffsetBuffer(\n  discriminator: number,\n  proofData?: string,\n  offset?: number,\n  useUInt32 = true\n): Buffer {\n  if (proofData) {\n    const proofBytes = Buffer.from(proofData, 'hex');\n    return Buffer.concat([Buffer.from([discriminator]), proofBytes]);\n  }\n  const offsetBuffer = Buffer.alloc(4);\n  if (useUInt32) {\n    offsetBuffer.writeUInt32LE(offset ?? 0, 0);\n  } else {\n    offsetBuffer.writeInt32LE(offset ?? 0, 0);\n  }\n  return Buffer.concat([Buffer.from([discriminator]), offsetBuffer]);\n}\n"]}