@bitgo-beta/sdk-coin-sol 7.6.4-beta.74 → 7.6.4-beta.741

package/dist/cjs/src/lib/utils.js

@@ -0,0 +1,665 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIdempotentAtaInstruction = isIdempotentAtaInstruction;
+exports.isValidAddress = isValidAddress;
+exports.isValidBlockId = isValidBlockId;
+exports.isValidPrivateKey = isValidPrivateKey;
+exports.isValidPublicKey = isValidPublicKey;
+exports.isValidSignature = isValidSignature;
+exports.isValidTransactionId = isValidTransactionId;
+exports.isValidAmount = isValidAmount;
+exports.isValidStakingAmount = isValidStakingAmount;
+exports.isValidMemo = isValidMemo;
+exports.isValidBase64 = isValidBase64;
+exports.isValidHex = isValidHex;
+exports.isValidRawTransaction = isValidRawTransaction;
+exports.verifySignature = verifySignature;
+exports.base58ToUint8Array = base58ToUint8Array;
+exports.Uint8ArrayTobase58 = Uint8ArrayTobase58;
+exports.countNotNullSignatures = countNotNullSignatures;
+exports.requiresAllSignatures = requiresAllSignatures;
+exports.matchTransactionTypeByInstructionsOrder = matchTransactionTypeByInstructionsOrder;
+exports.getTransactionType = getTransactionType;
+exports.getInstructionType = getInstructionType;
+exports.validateIntructionTypes = validateIntructionTypes;
+exports.validateRawMsgInstruction = validateRawMsgInstruction;
+exports.validateRawTransaction = validateRawTransaction;
+exports.validateAddress = validateAddress;
+exports.getSolTokenFromAddress = getSolTokenFromAddress;
+exports.getSolTokenFromAddressOnly = getSolTokenFromAddressOnly;
+exports.getSolTokenFromTokenName = getSolTokenFromTokenName;
+exports.getAssociatedTokenAccountAddress = getAssociatedTokenAccountAddress;
+exports.validateMintAddress = validateMintAddress;
+exports.validateOwnerAddress = validateOwnerAddress;
+exports.isSolLegacyInstruction = isSolLegacyInstruction;
+exports.computeTransferFee = computeTransferFee;
+const sdk_core_1 = require("@bitgo-beta/sdk-core");
+const statics_1 = require("@bitgo-beta/statics");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const assert_1 = __importDefault(require("assert"));
+const bignumber_js_1 = __importDefault(require("bignumber.js"));
+const bs58_1 = __importDefault(require("bs58"));
+const tweetnacl_1 = __importDefault(require("tweetnacl"));
+const constants_1 = require("./constants");
+const spl_stake_pool_1 = require("@solana/spl-stake-pool");
+const DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format
+const DECODED_SIGNATURE_LENGTH = 64; // https://docs.solana.com/terminology#signature
+const BASE_58_ENCONDING_REGEX = '[1-9A-HJ-NP-Za-km-z]';
+const COMPUTE_BUDGET = 'ComputeBudget111111111111111111111111111111';
+/**
+ * Checks if an ATA instruction is idempotent (discriminator byte = 1).
+ *
+ * Idempotent ATA instructions use Buffer.from([1]) as instruction data, created by
+ * @solana/spl-token's createAssociatedTokenAccountIdempotentInstruction() (v0.4.1+).
+ * An idempotent ATA instruction succeed even if account exists,
+ * preventing race condition errors in concurrent scenarios.
+ *
+ * @param {TransactionInstruction} instruction - The instruction to validate
+ * @returns {boolean} True if instruction data is a single byte with value 1
+ */
+function isIdempotentAtaInstruction(instruction) {
+    return instruction.data.length === 1 && instruction.data[0] === 1;
+}
+/** @inheritdoc */
+function isValidAddress(address) {
+    return isValidPublicKey(address);
+}
+/** @inheritdoc */
+function isValidBlockId(hash) {
+    try {
+        return (!!hash && new RegExp(BASE_58_ENCONDING_REGEX).test(hash) && bs58_1.default.decode(hash).length === DECODED_BLOCK_HASH_LENGTH);
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+function isValidPrivateKey(prvKey) {
+    try {
+        const key = typeof prvKey === 'string' ? base58ToUint8Array(prvKey) : prvKey;
+        return !!web3_js_1.Keypair.fromSecretKey(key);
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+function isValidPublicKey(pubKey) {
+    try {
+        if ((0, sdk_core_1.isValidXpub)(pubKey))
+            return true;
+        new web3_js_1.PublicKey(pubKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** @inheritdoc */
+function isValidSignature(signature) {
+    try {
+        return !!signature && bs58_1.default.decode(signature).length === DECODED_SIGNATURE_LENGTH;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+// TransactionId are the first signature on a Transaction
+function isValidTransactionId(txId) {
+    return isValidSignature(txId);
+}
+/**
+ * Returns whether or not the string is a valid amount of lamports number
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidAmount(amount) {
+    const bigNumberAmount = new bignumber_js_1.default(amount);
+    return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);
+}
+/**
+ * Check if the string is a valid amount of lamports number on staking
+ *
+ * @param {string} amount - the string to validate
+ * @returns {boolean} - the validation result
+ */
+function isValidStakingAmount(amount) {
+    const bigNumberAmount = new bignumber_js_1.default(amount);
+    return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThan(0);
+}
+/**
+ * Check if this is a valid memo or not.
+ *
+ * @param memo - the memo string
+ * @returns {boolean} - the validation result
+ */
+function isValidMemo(memo) {
+    return Buffer.from(memo).length <= constants_1.MAX_MEMO_LENGTH;
+}
+/**
+ * Checks if a string is valid base64 encoded data
+ * @param str - The string to validate
+ * @returns True if the string is valid base64, false otherwise
+ */
+function isValidBase64(str) {
+    try {
+        const decoded = Buffer.from(str, 'base64').toString('base64');
+        return decoded === str;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Checks if a string is valid hexadecimal data
+ * @param str - The string to validate
+ * @returns True if the string is valid hex, false otherwise
+ */
+function isValidHex(str) {
+    return /^[0-9A-Fa-f]*$/.test(str) && str.length % 2 === 0;
+}
+/**
+ * Checks if raw transaction can be deserialized
+ *
+ * @param {string} rawTransaction - transaction in base64 string format
+ * @param {boolean} requireAllSignatures - require all signatures to be present
+ * @param {boolean} verifySignatures - verify signatures
+ * @returns {boolean} - the validation result
+ */
+function isValidRawTransaction(rawTransaction, requireAllSignatures = false, verifySignatures = false) {
+    try {
+        const tx = web3_js_1.Transaction.from(Buffer.from(rawTransaction, 'base64'));
+        tx.serialize({ requireAllSignatures, verifySignatures });
+        return true;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/**
+ * Verifies if signature for message is valid.
+ *
+ * @param {Buffer} serializedTx - tx as a base64 string
+ * @param {string} signature - signature as a string
+ * @param {string} publicKey - public key as base 58
+ * @returns {Boolean} true if signature is valid.
+ */
+function verifySignature(serializedTx, signature, publicKey) {
+    if (!isValidRawTransaction(serializedTx)) {
+        throw new sdk_core_1.UtilsError('Invalid serializedTx');
+    }
+    if (!isValidPublicKey(publicKey)) {
+        throw new sdk_core_1.UtilsError('Invalid publicKey');
+    }
+    if (!isValidSignature(signature)) {
+        throw new sdk_core_1.UtilsError('Invalid signature');
+    }
+    const msg = web3_js_1.Transaction.from(Buffer.from(serializedTx, 'base64')).serializeMessage();
+    const sig = base58ToUint8Array(signature);
+    const pub = new web3_js_1.PublicKey(publicKey);
+    return tweetnacl_1.default.sign.detached.verify(msg, sig, pub.toBuffer());
+}
+/**
+ * Converts a base58 string into a Uint8Array.
+ *
+ * @param {string} input - a string in base58
+ * @returns {Uint8Array} - an Uint8Array
+ */
+function base58ToUint8Array(input) {
+    return new Uint8Array(bs58_1.default.decode(input));
+}
+/**
+ * Converts a Uint8Array to a base58 string.
+ *
+ * @param {Uint8Array} input - an Uint8Array
+ * @returns {string} - a string in base58
+ */
+function Uint8ArrayTobase58(input) {
+    return bs58_1.default.encode(input);
+}
+/**
+ * Count the amount of signatures are not null.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair
+ * @returns {number} - the amount of valid signatures
+ */
+function countNotNullSignatures(signatures) {
+    return signatures.filter((sig) => !!sig.signature).length;
+}
+/**
+ * Check if all signatures are completed.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - signatures
+ * @returns {boolean}
+ */
+function requiresAllSignatures(signatures) {
+    return signatures.length > 0 && countNotNullSignatures(signatures) === signatures.length;
+}
+/**
+ * Check the transaction type matching instructions by order. Memo and AdvanceNonceAccount instructions
+ * are ignored.
+ *
+ * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed
+ * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction
+ * @returns true if it matches by order.
+ */
+function matchTransactionTypeByInstructionsOrder(instructions, instructionIndexes) {
+    const instructionsCopy = [...instructions]; // Make a copy since we may modify the array below
+    // AdvanceNonceAccount and compute-budget instructions (SetComputeUnitLimit /
+    // SetPriorityFee) are optional leading instructions that don't affect the
+    // type-defining instruction order, so skip them the same way.
+    while (instructionsCopy.length > 0) {
+        const instructionType = getInstructionType(instructionsCopy[0]);
+        if (instructionType === 'AdvanceNonceAccount' ||
+            instructionType === constants_1.ValidInstructionTypesEnum.SetComputeUnitLimit ||
+            instructionType === constants_1.ValidInstructionTypesEnum.SetPriorityFee) {
+            instructionsCopy.shift();
+        }
+        else {
+            break;
+        }
+    }
+    // Memo is optional and the last instruction added, it does not matter to match the type
+    // Why have it in instructionKeys if we are going to ignore it?
+    const instructionsKeys = Object.keys(instructionIndexes);
+    if (instructionsKeys[instructionsKeys.length - 1] === 'Memo') {
+        instructionsKeys.pop();
+    }
+    // Check instructions by order using the index.
+    for (const keyName of instructionsKeys) {
+        const index = instructionIndexes[keyName];
+        if (index >= instructionsCopy.length) {
+            return false;
+        }
+        const result = getInstructionType(instructionsCopy[index]);
+        if (result !== keyName) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Returns true if the instruction is a confidential transfer instruction
+ * (Token-2022 CT extension or zk-elgamal-proof program).
+ *
+ * CT extension: byte 0 = 27 (ConfidentialTransferExtension), byte 1 ∈ {2, 5, 6, 7, 8}
+ * zk-elgamal-proof: any instruction from the zk-elgamal-proof program
+ */
+function isConfidentialTransferRawInstruction(instruction) {
+    const programId = instruction.programId.toString();
+    // zk-elgamal-proof program instructions are always CT proof verifications
+    if (programId === constants_1.ZK_ELGAMAL_PROOF_PROGRAM_ID) {
+        return true;
+    }
+    // Token-2022 CT extension: byte 0 = CT_EXT_DISCRIMINATOR, byte 1 ∈ CT_SUB_DISCRIMINATORS
+    if (programId === spl_token_1.TOKEN_2022_PROGRAM_ID.toString() && instruction.data.length >= 2) {
+        return instruction.data[0] === constants_1.CT_EXT_DISCRIMINATOR && constants_1.CT_SUB_DISCRIMINATORS.has(instruction.data[1]);
+    }
+    return false;
+}
+/**
+ * Returns the transaction Type based on the  transaction instructions.
+ * Wallet initialization, Transfer and Staking transactions are supported.
+ *
+ * @param {SolTransaction} transaction - the solana transaction
+ * @returns {TransactionType} - the type of transaction
+ */
+function getTransactionType(transaction) {
+    const { instructions } = transaction;
+    if (validateRawMsgInstruction(instructions)) {
+        return sdk_core_1.TransactionType.StakingAuthorizeRaw;
+    }
+    validateIntructionTypes(instructions);
+    // check if deactivate instruction does not exist because deactivate can be include a transfer instruction
+    const memoInstruction = instructions.find((instruction) => getInstructionType(instruction) === 'Memo');
+    const memoData = memoInstruction?.data.toString('utf-8');
+    if (memoData?.includes('WalletConnectDefiCustomTx')) {
+        return sdk_core_1.TransactionType.CustomTx;
+    }
+    // Check for close ATA instructions before classifying as Send.
+    // A bulk close-ATA tx contains only closeAccount instructions (zero-balance ATAs).
+    // Note: This assumes close-ATA transactions never contain TokenTransfer instructions.
+    // This holds for Phase 1 where non-zero balance ATAs are rejected (user must consolidate first).
+    // If atomic transfer+close is added in the future, this detection needs refinement.
+    const hasCloseAta = instructions.some((instruction) => getInstructionType(instruction) === constants_1.ValidInstructionTypesEnum.CloseAssociatedTokenAccount);
+    if (hasCloseAta) {
+        return sdk_core_1.TransactionType.CloseAssociatedTokenAccount;
+    }
+    if (instructions.filter((instruction) => getInstructionType(instruction) === 'Deactivate').length === 0) {
+        for (const instruction of instructions) {
+            const instructionType = getInstructionType(instruction);
+            // Check if memo instruction is there and if it contains 'PrepareForRevoke' because Marinade staking deactivate transaction will have this
+            if ((instructionType === constants_1.ValidInstructionTypesEnum.Transfer && !memoData?.includes('PrepareForRevoke')) ||
+                instructionType === constants_1.ValidInstructionTypesEnum.TokenTransfer) {
+                return sdk_core_1.TransactionType.Send;
+            }
+        }
+    }
+    if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.walletInitInstructionIndexes)) {
+        return sdk_core_1.TransactionType.WalletInitialization;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.marinadeStakingActivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.jitoStakingActivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.jitoStakingActivateWithATAInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingActivateInstructionsIndexes)) {
+        return sdk_core_1.TransactionType.StakingActivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingAuthorizeInstructionsIndexes)) {
+        return sdk_core_1.TransactionType.StakingAuthorize;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingDelegateInstructionsIndexes)) {
+        return sdk_core_1.TransactionType.StakingDelegate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.marinadeStakingDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingPartialDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, constants_1.jitoStakingDeactivateInstructionsIndexes)) {
+        return sdk_core_1.TransactionType.StakingDeactivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.stakingWithdrawInstructionsIndexes)) {
+        return sdk_core_1.TransactionType.StakingWithdraw;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.ataInitInstructionIndexes)) {
+        return sdk_core_1.TransactionType.AssociatedTokenAccountInitialization;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.ataCloseInstructionIndexes)) {
+        return sdk_core_1.TransactionType.CloseAssociatedTokenAccount;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, constants_1.ataRecoverNestedInstructionIndexes)) {
+        return sdk_core_1.TransactionType.CloseAssociatedTokenAccount;
+    }
+    else if (instructions.some(isConfidentialTransferRawInstruction)) {
+        return sdk_core_1.TransactionType.ConfidentialTransfer;
+    }
+    else {
+        return sdk_core_1.TransactionType.CustomTx;
+    }
+}
+/**
+ * Returns the instruction Type based on the solana instructions.
+ * Throws if the solana instruction program is not supported
+ *
+ * @param {TransactionInstruction} instruction - a solana instruction
+ * @returns {ValidInstructionTypes} - a solana instruction type
+ */
+function getInstructionType(instruction) {
+    switch (instruction.programId.toString()) {
+        case new web3_js_1.PublicKey(constants_1.MEMO_PROGRAM_PK).toString():
+            return 'Memo';
+        case web3_js_1.SystemProgram.programId.toString():
+            return web3_js_1.SystemInstruction.decodeInstructionType(instruction);
+        case spl_token_1.TOKEN_PROGRAM_ID.toString():
+        case spl_token_1.TOKEN_2022_PROGRAM_ID.toString():
+            if (instruction.programId.equals(spl_token_1.TOKEN_2022_PROGRAM_ID) &&
+                instruction.data.length >= 2 &&
+                instruction.data[0] === spl_token_1.TokenInstruction.TransferFeeExtension &&
+                instruction.data[1] === spl_token_1.TransferFeeInstruction.TransferCheckedWithFee) {
+                return 'TokenTransfer';
+            }
+            let decodedInstruction;
+            try {
+                decodedInstruction = (0, spl_token_1.decodeInstruction)(instruction, instruction.programId);
+            }
+            catch (e) {
+                // decodeInstruction only supports the base token instruction set —
+                // extension-family instructions (Pause, PermissionedBurn, transfer
+                // fee ops, ...) throw TokenInvalidInstructionTypeError at EVERY
+                // @solana/spl-token version. Those must not crash classification:
+                // fall back to CustomInstruction, the same path used below for
+                // decodable-but-unmapped instruction types.
+                return 'CustomInstruction';
+            }
+            const instructionTypeMap = new Map();
+            instructionTypeMap.set(spl_token_1.TokenInstruction.CloseAccount, 'CloseAssociatedTokenAccount');
+            instructionTypeMap.set(spl_token_1.TokenInstruction.Burn, 'Burn');
+            instructionTypeMap.set(spl_token_1.TokenInstruction.MintTo, 'MintTo');
+            instructionTypeMap.set(spl_token_1.TokenInstruction.Approve, 'Approve');
+            instructionTypeMap.set(spl_token_1.TokenInstruction.TransferChecked, 'TokenTransfer');
+            const validInstruction = instructionTypeMap.get(decodedInstruction.data.instruction);
+            if (!validInstruction) {
+                return 'CustomInstruction';
+            }
+            return validInstruction;
+        case spl_stake_pool_1.STAKE_POOL_PROGRAM_ID.toString():
+            const discriminator = instruction.data.readUint8(0);
+            const layoutKey = Object.entries(spl_stake_pool_1.STAKE_POOL_INSTRUCTION_LAYOUTS).find(([_, v]) => v.index === discriminator)?.[0];
+            if (layoutKey === undefined) {
+                throw new Error('Instruction type incorrect; unknown discriminator');
+            }
+            const instructionKey = layoutKey;
+            return instructionKey;
+        case web3_js_1.StakeProgram.programId.toString():
+            return web3_js_1.StakeInstruction.decodeInstructionType(instruction);
+        case constants_1.TOKEN_ACL_PROGRAM_ID:
+            // The Token ACL program has a single instruction the SDK builds — the permissionless thaw.
+            return constants_1.ValidInstructionTypesEnum.PermissionlessThawIdempotent;
+        case spl_token_1.ASSOCIATED_TOKEN_PROGRAM_ID.toString():
+            // TODO: change this when @spl-token supports decoding associated token instructions
+            // Support both legacy ATA creation (data.length === 0) and idempotent ATA creation (discriminator = 1)
+            // Both instruction types are treated as 'InitializeAssociatedTokenAccount' for compatibility
+            if (instruction.data.length === 0 || isIdempotentAtaInstruction(instruction)) {
+                return 'InitializeAssociatedTokenAccount';
+            }
+            else if (instruction.data.length === 1 && instruction.data[0] === 2) {
+                return 'RecoverNestedAssociatedTokenAccount';
+            }
+            else {
+                throw new sdk_core_1.NotSupported('Invalid transaction, instruction program id not supported: ' + instruction.programId.toString());
+            }
+        case COMPUTE_BUDGET:
+            if (web3_js_1.ComputeBudgetInstruction.decodeInstructionType(instruction) === 'SetComputeUnitLimit') {
+                return 'SetComputeUnitLimit';
+            }
+            return 'SetPriorityFee';
+        default:
+            return 'CustomInstruction';
+    }
+}
+/**
+ * Validate solana instructions types to see if they are supported by the builder.
+ * Throws if the instruction type is invalid.
+ *
+ * @param {TransactionInstruction} instructions - a solana instruction
+ * @returns {void}
+ */
+function validateIntructionTypes(instructions) {
+    for (const instruction of instructions) {
+        if (!constants_1.VALID_SYSTEM_INSTRUCTION_TYPES.includes(getInstructionType(instruction))) {
+            throw new sdk_core_1.NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));
+        }
+    }
+}
+/**
+ * Validate solana instructions match raw msg authorize transaction
+ *
+ * @param {TransactionInstruction} instructions - a solana instruction
+ * @returns {boolean} true if the instructions match the raw msg authorize transaction
+ */
+function validateRawMsgInstruction(instructions) {
+    // as web3.js cannot decode authorize instruction from CLI, we need to check it manually first
+    if (instructions.length === 2) {
+        const programId1 = instructions[0].programId.toString();
+        const programId2 = instructions[1].programId.toString();
+        if (programId1 === web3_js_1.SystemProgram.programId.toString() && programId2 === web3_js_1.StakeProgram.programId.toString()) {
+            const instructionName1 = web3_js_1.SystemInstruction.decodeInstructionType(instructions[0]);
+            const data = instructions[1].data.toString('hex');
+            if (instructionName1 === constants_1.nonceAdvanceInstruction &&
+                (data === constants_1.validInstructionData || data === constants_1.validInstructionData2)) {
+                return true;
+            }
+        }
+    }
+    if (instructions.length === 3) {
+        const programId1 = instructions[0].programId.toString();
+        const programId2 = instructions[1].programId.toString();
+        const programId3 = instructions[2].programId.toString();
+        if (programId1 === web3_js_1.SystemProgram.programId.toString() &&
+            programId2 === web3_js_1.StakeProgram.programId.toString() &&
+            programId3 === web3_js_1.StakeProgram.programId.toString()) {
+            const instructionName1 = web3_js_1.SystemInstruction.decodeInstructionType(instructions[0]);
+            const data = instructions[1].data.toString('hex');
+            const data2 = instructions[2].data.toString('hex');
+            if (instructionName1 === constants_1.nonceAdvanceInstruction &&
+                (data === constants_1.validInstructionData || data === constants_1.validInstructionData2) &&
+                (data2 === constants_1.validInstructionData || data2 === constants_1.validInstructionData2)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check the raw transaction has a valid format in the blockchain context, throw otherwise.
+ *
+ * @param {string} rawTransaction - Transaction in base64 string  format
+ */
+function validateRawTransaction(rawTransaction, requireAllSignatures = false, verifySignatures = false) {
+    if (!rawTransaction) {
+        throw new sdk_core_1.ParseTransactionError('Invalid raw transaction: Undefined');
+    }
+    if (!isValidRawTransaction(rawTransaction, requireAllSignatures, verifySignatures)) {
+        throw new sdk_core_1.ParseTransactionError('Invalid raw transaction');
+    }
+}
+/**
+ * Validates address to check if it exists and is a valid Solana public key
+ *
+ * @param {string} address The address to be validated
+ * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.
+ */
+function validateAddress(address, fieldName) {
+    if (!address || !isValidPublicKey(address)) {
+        throw new sdk_core_1.BuildTransactionError(`Invalid or missing ${fieldName}, got: ${address}`);
+    }
+}
+/**
+ * Get the statics coin object matching a given Solana token address if it exists
+ *
+ * @param tokenAddress The token address to match against
+ * @param network Solana Mainnet or Testnet
+ * @returns statics BaseCoin object for the matching token
+ */
+function getSolTokenFromAddress(tokenAddress, network) {
+    const tokens = statics_1.coins.filter((coin) => {
+        if (coin instanceof statics_1.SolCoin) {
+            return coin.network.type === network.type && coin.tokenAddress.toLowerCase() === tokenAddress.toLowerCase();
+        }
+        return false;
+    });
+    const tokensArray = tokens.map((token) => token);
+    if (tokensArray.length >= 1) {
+        // there should never be two tokens with the same contract address, so we assert that here
+        (0, assert_1.default)(tokensArray.length === 1);
+        return tokensArray[0];
+    }
+    return undefined;
+}
+/**
+ * Get the statics coin object matching a given Solana token address if it exists
+ *
+ * @param tokenAddress The token address to match against
+ * @param network Solana Mainnet or Testnet
+ * @returns statics BaseCoin object for the matching token
+ */
+function getSolTokenFromAddressOnly(tokenAddress) {
+    const tokens = statics_1.coins.filter((coin) => {
+        if (coin instanceof statics_1.SolCoin) {
+            return coin.tokenAddress.toLowerCase() === tokenAddress.toLowerCase();
+        }
+        return false;
+    });
+    const tokensArray = tokens.map((token) => token);
+    if (tokensArray.length >= 1) {
+        // there should never be two tokens with the same contract address, so we assert that here
+        (0, assert_1.default)(tokensArray.length === 1);
+        return tokensArray[0];
+    }
+    return undefined;
+}
+/**
+ * Get the solana token object from token name
+ * @param tokenName The token name to match against
+ * */
+function getSolTokenFromTokenName(tokenName) {
+    try {
+        const token = statics_1.coins.get(tokenName);
+        if (!(token.isToken && token instanceof statics_1.SolCoin)) {
+            return undefined;
+        }
+        return token;
+    }
+    catch (e) {
+        if (!(e instanceof statics_1.CoinNotDefinedError)) {
+            throw e;
+        }
+        return undefined;
+    }
+}
+/**
+ * Get the solana associated token account address
+ * @param tokenAddress token mint address
+ * @param ownerAddress The owner of the associated token account
+ * @returns The associated token account address
+ * */
+async function getAssociatedTokenAccountAddress(tokenMintAddress, ownerAddress, allowOwnerOffCurve = false, programId) {
+    const mintPublicKey = new web3_js_1.PublicKey(tokenMintAddress);
+    const ownerPublicKey = new web3_js_1.PublicKey(ownerAddress);
+    // tokenAddress are not on ed25519 curve, so they can't be used as ownerAddress
+    if (!allowOwnerOffCurve && !web3_js_1.PublicKey.isOnCurve(ownerPublicKey.toBuffer())) {
+        throw new sdk_core_1.UtilsError('Invalid ownerAddress - address off ed25519 curve, got: ' + ownerAddress);
+    }
+    if (!programId) {
+        const coin = getSolTokenFromAddressOnly(tokenMintAddress);
+        if (coin && coin instanceof statics_1.SolCoin && 'programId' in coin && coin.programId) {
+            programId = coin.programId.toString();
+        }
+        else {
+            programId = spl_token_1.TOKEN_PROGRAM_ID.toString();
+        }
+    }
+    let ataAddress;
+    if (programId === spl_token_1.TOKEN_2022_PROGRAM_ID.toString()) {
+        ataAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mintPublicKey, ownerPublicKey, allowOwnerOffCurve, spl_token_1.TOKEN_2022_PROGRAM_ID);
+    }
+    else {
+        ataAddress = await (0, spl_token_1.getAssociatedTokenAddress)(mintPublicKey, ownerPublicKey, allowOwnerOffCurve);
+    }
+    return ataAddress.toString();
+}
+function validateMintAddress(mintAddress) {
+    if (!mintAddress || !isValidAddress(mintAddress)) {
+        throw new sdk_core_1.BuildTransactionError('Invalid or missing mintAddress, got: ' + mintAddress);
+    }
+}
+function validateOwnerAddress(ownerAddress) {
+    if (!ownerAddress || !isValidAddress(ownerAddress)) {
+        throw new sdk_core_1.BuildTransactionError('Invalid or missing ownerAddress, got: ' + ownerAddress);
+    }
+}
+/**
+ * Type predicate to check if an instruction is a legacy SolInstruction.
+ * Uses 'programId' property as the discriminator since it's unique to legacy instructions
+ * Versioned instructions have 'programIdIndex' property.
+ *
+ * @param instruction - The instruction to check
+ * @returns True if the instruction is a SolInstruction (has programId field)
+ */
+function isSolLegacyInstruction(instruction) {
+    return 'programId' in instruction;
+}
+/**
+ * Token-2022 transfer fee: min(amount * basisPoints / 10000, maximumFee), in raw base units.
+ * All math in BigInt to avoid precision loss.
+ */
+function computeTransferFee(amount, basisPoints, maximumFee) {
+    const raw = (BigInt(amount) * BigInt(basisPoints)) / 10000n;
+    const cap = BigInt(maximumFee);
+    return (raw < cap ? raw : cap).toString();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/lib/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BuildTransactionError,\n  isValidXpub,\n  NotSupported,\n  ParseTransactionError,\n  SolInstruction,\n  SolVersionedInstruction,\n  TransactionType,\n  UtilsError,\n} from '@bitgo-beta/sdk-core';\nimport { BaseCoin, BaseNetwork, CoinNotDefinedError, coins, SolCoin } from '@bitgo-beta/statics';\nimport {\n  ASSOCIATED_TOKEN_PROGRAM_ID,\n  getAssociatedTokenAddress,\n  TOKEN_PROGRAM_ID,\n  TOKEN_2022_PROGRAM_ID,\n  decodeInstruction,\n  DecodedInstruction,\n  TokenInstruction,\n  TransferFeeInstruction,\n} from '@solana/spl-token';\nimport {\n  Keypair,\n  PublicKey,\n  SignaturePubkeyPair,\n  Transaction as SolTransaction,\n  StakeInstruction,\n  StakeProgram,\n  SystemInstruction,\n  SystemProgram,\n  TransactionInstruction,\n  ComputeBudgetInstruction,\n} from '@solana/web3.js';\nimport assert from 'assert';\nimport BigNumber from 'bignumber.js';\nimport bs58 from 'bs58';\nimport nacl from 'tweetnacl';\nimport {\n  ataCloseInstructionIndexes,\n  ataInitInstructionIndexes,\n  ataRecoverNestedInstructionIndexes,\n  MAX_MEMO_LENGTH,\n  MEMO_PROGRAM_PK,\n  nonceAdvanceInstruction,\n  stakingActivateInstructionsIndexes,\n  marinadeStakingActivateInstructionsIndexes,\n  stakingAuthorizeInstructionsIndexes,\n  stakingDeactivateInstructionsIndexes,\n  marinadeStakingDeactivateInstructionsIndexes,\n  stakingDelegateInstructionsIndexes,\n  stakingPartialDeactivateInstructionsIndexes,\n  stakingWithdrawInstructionsIndexes,\n  VALID_SYSTEM_INSTRUCTION_TYPES,\n  validInstructionData,\n  validInstructionData2,\n  ValidInstructionTypesEnum,\n  walletInitInstructionIndexes,\n  jitoStakingActivateInstructionsIndexes,\n  jitoStakingDeactivateInstructionsIndexes,\n  jitoStakingActivateWithATAInstructionsIndexes,\n  TOKEN_ACL_PROGRAM_ID,\n  ZK_ELGAMAL_PROOF_PROGRAM_ID,\n  CT_EXT_DISCRIMINATOR,\n  CT_SUB_DISCRIMINATORS,\n} from './constants';\nimport { ValidInstructionTypes } from './iface';\nimport { STAKE_POOL_INSTRUCTION_LAYOUTS, STAKE_POOL_PROGRAM_ID } from '@solana/spl-stake-pool';\n\nconst DECODED_BLOCK_HASH_LENGTH = 32; // https://docs.solana.com/developing/programming-model/transactions#blockhash-format\nconst DECODED_SIGNATURE_LENGTH = 64; // https://docs.solana.com/terminology#signature\nconst BASE_58_ENCONDING_REGEX = '[1-9A-HJ-NP-Za-km-z]';\nconst COMPUTE_BUDGET = 'ComputeBudget111111111111111111111111111111';\n\n/**\n * Checks if an ATA instruction is idempotent (discriminator byte = 1).\n *\n * Idempotent ATA instructions use Buffer.from([1]) as instruction data, created by\n * @solana/spl-token's createAssociatedTokenAccountIdempotentInstruction() (v0.4.1+).\n * An idempotent ATA instruction succeed even if account exists,\n * preventing race condition errors in concurrent scenarios.\n *\n * @param {TransactionInstruction} instruction - The instruction to validate\n * @returns {boolean} True if instruction data is a single byte with value 1\n */\nexport function isIdempotentAtaInstruction(instruction: TransactionInstruction): boolean {\n  return instruction.data.length === 1 && instruction.data[0] === 1;\n}\n\n/** @inheritdoc */\nexport function isValidAddress(address: string): boolean {\n  return isValidPublicKey(address);\n}\n\n/** @inheritdoc */\nexport function isValidBlockId(hash: string): boolean {\n  try {\n    return (\n      !!hash && new RegExp(BASE_58_ENCONDING_REGEX).test(hash) && bs58.decode(hash).length === DECODED_BLOCK_HASH_LENGTH\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidPrivateKey(prvKey: string | Uint8Array): boolean {\n  try {\n    const key: Uint8Array = typeof prvKey === 'string' ? base58ToUint8Array(prvKey) : prvKey;\n    return !!Keypair.fromSecretKey(key);\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidPublicKey(pubKey: string): boolean {\n  try {\n    if (isValidXpub(pubKey)) return true;\n    new PublicKey(pubKey);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\n/** @inheritdoc */\nexport function isValidSignature(signature: string): boolean {\n  try {\n    return !!signature && bs58.decode(signature).length === DECODED_SIGNATURE_LENGTH;\n  } catch (e) {\n    return false;\n  }\n}\n\n/** @inheritdoc */\n// TransactionId are the first signature on a Transaction\nexport function isValidTransactionId(txId: string): boolean {\n  return isValidSignature(txId);\n}\n\n/**\n * Returns whether or not the string is a valid amount of lamports number\n *\n * @param {string} amount - the string to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidAmount(amount: string): boolean {\n  const bigNumberAmount = new BigNumber(amount);\n  return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThanOrEqualTo(0);\n}\n\n/**\n * Check if the string is a valid amount of lamports number on staking\n *\n * @param {string} amount - the string to validate\n * @returns {boolean} - the validation result\n */\nexport function isValidStakingAmount(amount: string): boolean {\n  const bigNumberAmount = new BigNumber(amount);\n  return bigNumberAmount.isInteger() && bigNumberAmount.isGreaterThan(0);\n}\n\n/**\n * Check if this is a valid memo or not.\n *\n * @param memo - the memo string\n * @returns {boolean} - the validation result\n */\nexport function isValidMemo(memo: string): boolean {\n  return Buffer.from(memo).length <= MAX_MEMO_LENGTH;\n}\n\n/**\n * Checks if a string is valid base64 encoded data\n * @param str - The string to validate\n * @returns True if the string is valid base64, false otherwise\n */\nexport function isValidBase64(str: string): boolean {\n  try {\n    const decoded = Buffer.from(str, 'base64').toString('base64');\n    return decoded === str;\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Checks if a string is valid hexadecimal data\n * @param str - The string to validate\n * @returns True if the string is valid hex, false otherwise\n */\nexport function isValidHex(str: string): boolean {\n  return /^[0-9A-Fa-f]*$/.test(str) && str.length % 2 === 0;\n}\n\n/**\n * Checks if raw transaction can be deserialized\n *\n * @param {string} rawTransaction - transaction in base64 string format\n * @param {boolean} requireAllSignatures - require all signatures to be present\n * @param {boolean} verifySignatures - verify signatures\n * @returns {boolean} - the validation result\n */\nexport function isValidRawTransaction(\n  rawTransaction: string,\n  requireAllSignatures = false,\n  verifySignatures = false\n): boolean {\n  try {\n    const tx = SolTransaction.from(Buffer.from(rawTransaction, 'base64'));\n    tx.serialize({ requireAllSignatures, verifySignatures });\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Verifies if signature for message is valid.\n *\n * @param {Buffer} serializedTx - tx as a base64 string\n * @param {string} signature - signature as a string\n * @param {string} publicKey - public key as base 58\n * @returns {Boolean} true if signature is valid.\n */\nexport function verifySignature(serializedTx: string, signature: string, publicKey: string): boolean {\n  if (!isValidRawTransaction(serializedTx)) {\n    throw new UtilsError('Invalid serializedTx');\n  }\n  if (!isValidPublicKey(publicKey)) {\n    throw new UtilsError('Invalid publicKey');\n  }\n  if (!isValidSignature(signature)) {\n    throw new UtilsError('Invalid signature');\n  }\n  const msg = SolTransaction.from(Buffer.from(serializedTx, 'base64')).serializeMessage();\n  const sig = base58ToUint8Array(signature);\n  const pub = new PublicKey(publicKey);\n  return nacl.sign.detached.verify(msg, sig, pub.toBuffer());\n}\n\n/**\n * Converts a base58 string into a Uint8Array.\n *\n * @param {string} input - a string in base58\n * @returns {Uint8Array} - an Uint8Array\n */\nexport function base58ToUint8Array(input: string): Uint8Array {\n  return new Uint8Array(bs58.decode(input));\n}\n\n/**\n * Converts a Uint8Array to a base58 string.\n *\n * @param {Uint8Array} input - an Uint8Array\n * @returns {string} - a string in base58\n */\nexport function Uint8ArrayTobase58(input: Uint8Array): string {\n  return bs58.encode(input);\n}\n\n/**\n * Count the amount of signatures are not null.\n *\n * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair\n * @returns {number} - the amount of valid signatures\n */\nexport function countNotNullSignatures(signatures: SignaturePubkeyPair[]): number {\n  return signatures.filter((sig) => !!sig.signature).length;\n}\n\n/**\n * Check if all signatures are completed.\n *\n * @param {SignaturePubkeyPair[]} signatures - signatures\n * @returns {boolean}\n */\nexport function requiresAllSignatures(signatures: SignaturePubkeyPair[]): boolean {\n  return signatures.length > 0 && countNotNullSignatures(signatures) === signatures.length;\n}\n\n/**\n * Check the transaction type matching instructions by order. Memo and AdvanceNonceAccount instructions\n * are ignored.\n *\n * @param {TransactionInstruction[]} instructions - the array of supported Solana instructions to be parsed\n * @param {Record<string, number>} instructionIndexes - the instructions indexes of the current transaction\n * @returns true if it matches by order.\n */\nexport function matchTransactionTypeByInstructionsOrder(\n  instructions: TransactionInstruction[],\n  instructionIndexes: Record<string, number>\n): boolean {\n  const instructionsCopy = [...instructions]; // Make a copy since we may modify the array below\n  // AdvanceNonceAccount and compute-budget instructions (SetComputeUnitLimit /\n  // SetPriorityFee) are optional leading instructions that don't affect the\n  // type-defining instruction order, so skip them the same way.\n  while (instructionsCopy.length > 0) {\n    const instructionType = getInstructionType(instructionsCopy[0]);\n    if (\n      instructionType === 'AdvanceNonceAccount' ||\n      instructionType === ValidInstructionTypesEnum.SetComputeUnitLimit ||\n      instructionType === ValidInstructionTypesEnum.SetPriorityFee\n    ) {\n      instructionsCopy.shift();\n    } else {\n      break;\n    }\n  }\n\n  // Memo is optional and the last instruction added, it does not matter to match the type\n  // Why have it in instructionKeys if we are going to ignore it?\n  const instructionsKeys = Object.keys(instructionIndexes);\n  if (instructionsKeys[instructionsKeys.length - 1] === 'Memo') {\n    instructionsKeys.pop();\n  }\n\n  // Check instructions by order using the index.\n  for (const keyName of instructionsKeys) {\n    const index = instructionIndexes[keyName];\n    if (index >= instructionsCopy.length) {\n      return false;\n    }\n    const result = getInstructionType(instructionsCopy[index]);\n    if (result !== keyName) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * Returns true if the instruction is a confidential transfer instruction\n * (Token-2022 CT extension or zk-elgamal-proof program).\n *\n * CT extension: byte 0 = 27 (ConfidentialTransferExtension), byte 1 ∈ {2, 5, 6, 7, 8}\n * zk-elgamal-proof: any instruction from the zk-elgamal-proof program\n */\nfunction isConfidentialTransferRawInstruction(instruction: TransactionInstruction): boolean {\n  const programId = instruction.programId.toString();\n  // zk-elgamal-proof program instructions are always CT proof verifications\n  if (programId === ZK_ELGAMAL_PROOF_PROGRAM_ID) {\n    return true;\n  }\n  // Token-2022 CT extension: byte 0 = CT_EXT_DISCRIMINATOR, byte 1 ∈ CT_SUB_DISCRIMINATORS\n  if (programId === TOKEN_2022_PROGRAM_ID.toString() && instruction.data.length >= 2) {\n    return instruction.data[0] === CT_EXT_DISCRIMINATOR && CT_SUB_DISCRIMINATORS.has(instruction.data[1]);\n  }\n  return false;\n}\n\n/**\n * Returns the transaction Type based on the  transaction instructions.\n * Wallet initialization, Transfer and Staking transactions are supported.\n *\n * @param {SolTransaction} transaction - the solana transaction\n * @returns {TransactionType} - the type of transaction\n */\nexport function getTransactionType(transaction: SolTransaction): TransactionType {\n  const { instructions } = transaction;\n  if (validateRawMsgInstruction(instructions)) {\n    return TransactionType.StakingAuthorizeRaw;\n  }\n  validateIntructionTypes(instructions);\n  // check if deactivate instruction does not exist because deactivate can be include a transfer instruction\n  const memoInstruction = instructions.find((instruction) => getInstructionType(instruction) === 'Memo');\n  const memoData = memoInstruction?.data.toString('utf-8');\n  if (memoData?.includes('WalletConnectDefiCustomTx')) {\n    return TransactionType.CustomTx;\n  }\n  // Check for close ATA instructions before classifying as Send.\n  // A bulk close-ATA tx contains only closeAccount instructions (zero-balance ATAs).\n  // Note: This assumes close-ATA transactions never contain TokenTransfer instructions.\n  // This holds for Phase 1 where non-zero balance ATAs are rejected (user must consolidate first).\n  // If atomic transfer+close is added in the future, this detection needs refinement.\n  const hasCloseAta = instructions.some(\n    (instruction) => getInstructionType(instruction) === ValidInstructionTypesEnum.CloseAssociatedTokenAccount\n  );\n  if (hasCloseAta) {\n    return TransactionType.CloseAssociatedTokenAccount;\n  }\n\n  if (instructions.filter((instruction) => getInstructionType(instruction) === 'Deactivate').length === 0) {\n    for (const instruction of instructions) {\n      const instructionType = getInstructionType(instruction);\n      // Check if memo instruction is there and if it contains 'PrepareForRevoke' because Marinade staking deactivate transaction will have this\n      if (\n        (instructionType === ValidInstructionTypesEnum.Transfer && !memoData?.includes('PrepareForRevoke')) ||\n        instructionType === ValidInstructionTypesEnum.TokenTransfer\n      ) {\n        return TransactionType.Send;\n      }\n    }\n  }\n  if (matchTransactionTypeByInstructionsOrder(instructions, walletInitInstructionIndexes)) {\n    return TransactionType.WalletInitialization;\n  } else if (\n    matchTransactionTypeByInstructionsOrder(instructions, marinadeStakingActivateInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, jitoStakingActivateInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, jitoStakingActivateWithATAInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, stakingActivateInstructionsIndexes)\n  ) {\n    return TransactionType.StakingActivate;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingAuthorizeInstructionsIndexes)) {\n    return TransactionType.StakingAuthorize;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingDelegateInstructionsIndexes)) {\n    return TransactionType.StakingDelegate;\n  } else if (\n    matchTransactionTypeByInstructionsOrder(instructions, marinadeStakingDeactivateInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, stakingDeactivateInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, stakingPartialDeactivateInstructionsIndexes) ||\n    matchTransactionTypeByInstructionsOrder(instructions, jitoStakingDeactivateInstructionsIndexes)\n  ) {\n    return TransactionType.StakingDeactivate;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, stakingWithdrawInstructionsIndexes)) {\n    return TransactionType.StakingWithdraw;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, ataInitInstructionIndexes)) {\n    return TransactionType.AssociatedTokenAccountInitialization;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, ataCloseInstructionIndexes)) {\n    return TransactionType.CloseAssociatedTokenAccount;\n  } else if (matchTransactionTypeByInstructionsOrder(instructions, ataRecoverNestedInstructionIndexes)) {\n    return TransactionType.CloseAssociatedTokenAccount;\n  } else if (instructions.some(isConfidentialTransferRawInstruction)) {\n    return TransactionType.ConfidentialTransfer;\n  } else {\n    return TransactionType.CustomTx;\n  }\n}\n\n/**\n * Returns the instruction Type based on the solana instructions.\n * Throws if the solana instruction program is not supported\n *\n * @param {TransactionInstruction} instruction - a solana instruction\n * @returns {ValidInstructionTypes} - a solana instruction type\n */\nexport function getInstructionType(instruction: TransactionInstruction): ValidInstructionTypes {\n  switch (instruction.programId.toString()) {\n    case new PublicKey(MEMO_PROGRAM_PK).toString():\n      return 'Memo';\n    case SystemProgram.programId.toString():\n      return SystemInstruction.decodeInstructionType(instruction);\n    case TOKEN_PROGRAM_ID.toString():\n    case TOKEN_2022_PROGRAM_ID.toString():\n      if (\n        instruction.programId.equals(TOKEN_2022_PROGRAM_ID) &&\n        instruction.data.length >= 2 &&\n        instruction.data[0] === TokenInstruction.TransferFeeExtension &&\n        instruction.data[1] === TransferFeeInstruction.TransferCheckedWithFee\n      ) {\n        return 'TokenTransfer';\n      }\n      let decodedInstruction: DecodedInstruction;\n      try {\n        decodedInstruction = decodeInstruction(instruction, instruction.programId);\n      } catch (e) {\n        // decodeInstruction only supports the base token instruction set —\n        // extension-family instructions (Pause, PermissionedBurn, transfer\n        // fee ops, ...) throw TokenInvalidInstructionTypeError at EVERY\n        // @solana/spl-token version. Those must not crash classification:\n        // fall back to CustomInstruction, the same path used below for\n        // decodable-but-unmapped instruction types.\n        return 'CustomInstruction';\n      }\n      const instructionTypeMap: Map<TokenInstruction, ValidInstructionTypes> = new Map();\n      instructionTypeMap.set(TokenInstruction.CloseAccount, 'CloseAssociatedTokenAccount');\n      instructionTypeMap.set(TokenInstruction.Burn, 'Burn');\n      instructionTypeMap.set(TokenInstruction.MintTo, 'MintTo');\n      instructionTypeMap.set(TokenInstruction.Approve, 'Approve');\n      instructionTypeMap.set(TokenInstruction.TransferChecked, 'TokenTransfer');\n      const validInstruction = instructionTypeMap.get(decodedInstruction.data.instruction);\n      if (!validInstruction) {\n        return 'CustomInstruction';\n      }\n      return validInstruction;\n    case STAKE_POOL_PROGRAM_ID.toString():\n      const discriminator = instruction.data.readUint8(0);\n      const layoutKey = Object.entries(STAKE_POOL_INSTRUCTION_LAYOUTS).find(([_, v]) => v.index === discriminator)?.[0];\n      if (layoutKey === undefined) {\n        throw new Error('Instruction type incorrect; unknown discriminator');\n      }\n      const instructionKey = layoutKey as keyof typeof STAKE_POOL_INSTRUCTION_LAYOUTS;\n      return instructionKey;\n    case StakeProgram.programId.toString():\n      return StakeInstruction.decodeInstructionType(instruction);\n    case TOKEN_ACL_PROGRAM_ID:\n      // The Token ACL program has a single instruction the SDK builds — the permissionless thaw.\n      return ValidInstructionTypesEnum.PermissionlessThawIdempotent;\n    case ASSOCIATED_TOKEN_PROGRAM_ID.toString():\n      // TODO: change this when @spl-token supports decoding associated token instructions\n      // Support both legacy ATA creation (data.length === 0) and idempotent ATA creation (discriminator = 1)\n      // Both instruction types are treated as 'InitializeAssociatedTokenAccount' for compatibility\n      if (instruction.data.length === 0 || isIdempotentAtaInstruction(instruction)) {\n        return 'InitializeAssociatedTokenAccount';\n      } else if (instruction.data.length === 1 && instruction.data[0] === 2) {\n        return 'RecoverNestedAssociatedTokenAccount';\n      } else {\n        throw new NotSupported(\n          'Invalid transaction, instruction program id not supported: ' + instruction.programId.toString()\n        );\n      }\n    case COMPUTE_BUDGET:\n      if (ComputeBudgetInstruction.decodeInstructionType(instruction) === 'SetComputeUnitLimit') {\n        return 'SetComputeUnitLimit';\n      }\n      return 'SetPriorityFee';\n    default:\n      return 'CustomInstruction';\n  }\n}\n\n/**\n * Validate solana instructions types to see if they are supported by the builder.\n * Throws if the instruction type is invalid.\n *\n * @param {TransactionInstruction} instructions - a solana instruction\n * @returns {void}\n */\nexport function validateIntructionTypes(instructions: TransactionInstruction[]): void {\n  for (const instruction of instructions) {\n    if (!VALID_SYSTEM_INSTRUCTION_TYPES.includes(getInstructionType(instruction))) {\n      throw new NotSupported('Invalid transaction, instruction type not supported: ' + getInstructionType(instruction));\n    }\n  }\n}\n\n/**\n * Validate solana instructions match raw msg authorize transaction\n *\n * @param {TransactionInstruction} instructions - a solana instruction\n * @returns {boolean} true if the instructions match the raw msg authorize transaction\n */\nexport function validateRawMsgInstruction(instructions: TransactionInstruction[]): boolean {\n  // as web3.js cannot decode authorize instruction from CLI, we need to check it manually first\n  if (instructions.length === 2) {\n    const programId1 = instructions[0].programId.toString();\n    const programId2 = instructions[1].programId.toString();\n    if (programId1 === SystemProgram.programId.toString() && programId2 === StakeProgram.programId.toString()) {\n      const instructionName1 = SystemInstruction.decodeInstructionType(instructions[0]);\n      const data = instructions[1].data.toString('hex');\n      if (\n        instructionName1 === nonceAdvanceInstruction &&\n        (data === validInstructionData || data === validInstructionData2)\n      ) {\n        return true;\n      }\n    }\n  }\n  if (instructions.length === 3) {\n    const programId1 = instructions[0].programId.toString();\n    const programId2 = instructions[1].programId.toString();\n    const programId3 = instructions[2].programId.toString();\n    if (\n      programId1 === SystemProgram.programId.toString() &&\n      programId2 === StakeProgram.programId.toString() &&\n      programId3 === StakeProgram.programId.toString()\n    ) {\n      const instructionName1 = SystemInstruction.decodeInstructionType(instructions[0]);\n      const data = instructions[1].data.toString('hex');\n      const data2 = instructions[2].data.toString('hex');\n      if (\n        instructionName1 === nonceAdvanceInstruction &&\n        (data === validInstructionData || data === validInstructionData2) &&\n        (data2 === validInstructionData || data2 === validInstructionData2)\n      ) {\n        return true;\n      }\n    }\n  }\n  return false;\n}\n/**\n * Check the raw transaction has a valid format in the blockchain context, throw otherwise.\n *\n * @param {string} rawTransaction - Transaction in base64 string  format\n */\nexport function validateRawTransaction(\n  rawTransaction: string,\n  requireAllSignatures = false,\n  verifySignatures = false\n): void {\n  if (!rawTransaction) {\n    throw new ParseTransactionError('Invalid raw transaction: Undefined');\n  }\n  if (!isValidRawTransaction(rawTransaction, requireAllSignatures, verifySignatures)) {\n    throw new ParseTransactionError('Invalid raw transaction');\n  }\n}\n\n/**\n * Validates address to check if it exists and is a valid Solana public key\n *\n * @param {string} address The address to be validated\n * @param {string} fieldName Name of the field to validate, its needed to return which field is failing on case of error.\n */\nexport function validateAddress(address: string, fieldName: string): void {\n  if (!address || !isValidPublicKey(address)) {\n    throw new BuildTransactionError(`Invalid or missing ${fieldName}, got: ${address}`);\n  }\n}\n\n/**\n * Get the statics coin object matching a given Solana token address if it exists\n *\n * @param tokenAddress The token address to match against\n * @param network Solana Mainnet or Testnet\n * @returns statics BaseCoin object for the matching token\n */\nexport function getSolTokenFromAddress(tokenAddress: string, network: BaseNetwork): Readonly<BaseCoin> | undefined {\n  const tokens = coins.filter((coin) => {\n    if (coin instanceof SolCoin) {\n      return coin.network.type === network.type && coin.tokenAddress.toLowerCase() === tokenAddress.toLowerCase();\n    }\n    return false;\n  });\n  const tokensArray = tokens.map((token) => token);\n  if (tokensArray.length >= 1) {\n    // there should never be two tokens with the same contract address, so we assert that here\n    assert(tokensArray.length === 1);\n    return tokensArray[0];\n  }\n  return undefined;\n}\n\n/**\n * Get the statics coin object matching a given Solana token address if it exists\n *\n * @param tokenAddress The token address to match against\n * @param network Solana Mainnet or Testnet\n * @returns statics BaseCoin object for the matching token\n */\nexport function getSolTokenFromAddressOnly(tokenAddress: string): Readonly<BaseCoin> | undefined {\n  const tokens = coins.filter((coin) => {\n    if (coin instanceof SolCoin) {\n      return coin.tokenAddress.toLowerCase() === tokenAddress.toLowerCase();\n    }\n    return false;\n  });\n  const tokensArray = tokens.map((token) => token);\n  if (tokensArray.length >= 1) {\n    // there should never be two tokens with the same contract address, so we assert that here\n    assert(tokensArray.length === 1);\n    return tokensArray[0];\n  }\n  return undefined;\n}\n\n/**\n * Get the solana token object from token name\n * @param tokenName The token name to match against\n * */\nexport function getSolTokenFromTokenName(tokenName: string): Readonly<SolCoin> | undefined {\n  try {\n    const token = coins.get(tokenName);\n    if (!(token.isToken && token instanceof SolCoin)) {\n      return undefined;\n    }\n    return token;\n  } catch (e) {\n    if (!(e instanceof CoinNotDefinedError)) {\n      throw e;\n    }\n    return undefined;\n  }\n}\n\n/**\n * Get the solana associated token account address\n * @param tokenAddress token mint address\n * @param ownerAddress The owner of the associated token account\n * @returns The associated token account address\n * */\nexport async function getAssociatedTokenAccountAddress(\n  tokenMintAddress: string,\n  ownerAddress: string,\n  allowOwnerOffCurve = false,\n  programId?: string\n): Promise<string> {\n  const mintPublicKey = new PublicKey(tokenMintAddress);\n  const ownerPublicKey = new PublicKey(ownerAddress);\n\n  // tokenAddress are not on ed25519 curve, so they can't be used as ownerAddress\n  if (!allowOwnerOffCurve && !PublicKey.isOnCurve(ownerPublicKey.toBuffer())) {\n    throw new UtilsError('Invalid ownerAddress - address off ed25519 curve, got: ' + ownerAddress);\n  }\n\n  if (!programId) {\n    const coin = getSolTokenFromAddressOnly(tokenMintAddress);\n    if (coin && coin instanceof SolCoin && 'programId' in coin && coin.programId) {\n      programId = coin.programId.toString();\n    } else {\n      programId = TOKEN_PROGRAM_ID.toString();\n    }\n  }\n\n  let ataAddress: PublicKey;\n  if (programId === TOKEN_2022_PROGRAM_ID.toString()) {\n    ataAddress = await getAssociatedTokenAddress(\n      mintPublicKey,\n      ownerPublicKey,\n      allowOwnerOffCurve,\n      TOKEN_2022_PROGRAM_ID\n    );\n  } else {\n    ataAddress = await getAssociatedTokenAddress(mintPublicKey, ownerPublicKey, allowOwnerOffCurve);\n  }\n  return ataAddress.toString();\n}\n\nexport function validateMintAddress(mintAddress: string): void {\n  if (!mintAddress || !isValidAddress(mintAddress)) {\n    throw new BuildTransactionError('Invalid or missing mintAddress, got: ' + mintAddress);\n  }\n}\n\nexport function validateOwnerAddress(ownerAddress: string): void {\n  if (!ownerAddress || !isValidAddress(ownerAddress)) {\n    throw new BuildTransactionError('Invalid or missing ownerAddress, got: ' + ownerAddress);\n  }\n}\n\n/**\n * Type predicate to check if an instruction is a legacy SolInstruction.\n * Uses 'programId' property as the discriminator since it's unique to legacy instructions\n * Versioned instructions have 'programIdIndex' property.\n *\n * @param instruction - The instruction to check\n * @returns True if the instruction is a SolInstruction (has programId field)\n */\nexport function isSolLegacyInstruction(\n  instruction: SolInstruction | SolVersionedInstruction\n): instruction is SolInstruction {\n  return 'programId' in instruction;\n}\n\n/**\n * Token-2022 transfer fee: min(amount * basisPoints / 10000, maximumFee), in raw base units.\n * All math in BigInt to avoid precision loss.\n */\nexport function computeTransferFee(amount: string, basisPoints: number, maximumFee: string): string {\n  const raw = (BigInt(amount) * BigInt(basisPoints)) / 10000n;\n  const cap = BigInt(maximumFee);\n  return (raw < cap ? raw : cap).toString();\n}\n"]}