@bitgo-beta/sdk-coin-sol 7.6.4-beta.31 → 7.6.4-beta.310

package/dist/esm/lib/utils.js

@@ -0,0 +1,558 @@
+import { BuildTransactionError, isValidXpub, NotSupported, ParseTransactionError, TransactionType, UtilsError, } from '@bitgo-beta/sdk-core';
+import { CoinNotDefinedError, coins, SolCoin } from '@bitgo-beta/statics';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, getAssociatedTokenAddress, TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, decodeInstruction, TokenInstruction, } from '@solana/spl-token';
+import { Keypair, PublicKey, Transaction as SolTransaction, StakeInstruction, StakeProgram, SystemInstruction, SystemProgram, ComputeBudgetInstruction, } from '@solana/web3.js';
+import assert from 'assert';
+import BigNumber from 'bignumber.js';
+import bs58 from 'bs58';
+import nacl from 'tweetnacl';
+import { ataCloseInstructionIndexes, ataInitInstructionIndexes, ataRecoverNestedInstructionIndexes, MAX_MEMO_LENGTH, MEMO_PROGRAM_PK, nonceAdvanceInstruction, stakingActivateInstructionsIndexes, marinadeStakingActivateInstructionsIndexes, stakingAuthorizeInstructionsIndexes, stakingDeactivateInstructionsIndexes, marinadeStakingDeactivateInstructionsIndexes, stakingDelegateInstructionsIndexes, stakingPartialDeactivateInstructionsIndexes, stakingWithdrawInstructionsIndexes, VALID_SYSTEM_INSTRUCTION_TYPES, validInstructionData, validInstructionData2, ValidInstructionTypesEnum, walletInitInstructionIndexes, jitoStakingActivateInstructionsIndexes, jitoStakingDeactivateInstructionsIndexes, jitoStakingActivateWithATAInstructionsIndexes, } from './constants';
+import { STAKE_POOL_INSTRUCTION_LAYOUTS, STAKE_POOL_PROGRAM_ID } from '@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
+ */
+export function isIdempotentAtaInstruction(instruction) {
+    return instruction.data.length === 1 && instruction.data[0] === 1;
+}
+/** @inheritdoc */
+export function isValidAddress(address) {
+    return isValidPublicKey(address);
+}
+/** @inheritdoc */
+export function isValidBlockId(hash) {
+    try {
+        return (!!hash && new RegExp(BASE_58_ENCONDING_REGEX).test(hash) && bs58.decode(hash).length === DECODED_BLOCK_HASH_LENGTH);
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+export function isValidPrivateKey(prvKey) {
+    try {
+        const key = typeof prvKey === 'string' ? base58ToUint8Array(prvKey) : prvKey;
+        return !!Keypair.fromSecretKey(key);
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+export function isValidPublicKey(pubKey) {
+    try {
+        if (isValidXpub(pubKey))
+            return true;
+        new PublicKey(pubKey);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** @inheritdoc */
+export function isValidSignature(signature) {
+    try {
+        return !!signature && bs58.decode(signature).length === DECODED_SIGNATURE_LENGTH;
+    }
+    catch (e) {
+        return false;
+    }
+}
+/** @inheritdoc */
+// TransactionId are the first signature on a Transaction
+export 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
+ */
+export function isValidAmount(amount) {
+    const bigNumberAmount = new BigNumber(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
+ */
+export function isValidStakingAmount(amount) {
+    const bigNumberAmount = new BigNumber(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
+ */
+export function isValidMemo(memo) {
+    return Buffer.from(memo).length <= 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
+ */
+export 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
+ */
+export 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
+ */
+export function isValidRawTransaction(rawTransaction, requireAllSignatures = false, verifySignatures = false) {
+    try {
+        const tx = SolTransaction.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.
+ */
+export function verifySignature(serializedTx, signature, publicKey) {
+    if (!isValidRawTransaction(serializedTx)) {
+        throw new UtilsError('Invalid serializedTx');
+    }
+    if (!isValidPublicKey(publicKey)) {
+        throw new UtilsError('Invalid publicKey');
+    }
+    if (!isValidSignature(signature)) {
+        throw new UtilsError('Invalid signature');
+    }
+    const msg = SolTransaction.from(Buffer.from(serializedTx, 'base64')).serializeMessage();
+    const sig = base58ToUint8Array(signature);
+    const pub = new PublicKey(publicKey);
+    return nacl.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
+ */
+export function base58ToUint8Array(input) {
+    return new Uint8Array(bs58.decode(input));
+}
+/**
+ * Converts a Uint8Array to a base58 string.
+ *
+ * @param {Uint8Array} input - an Uint8Array
+ * @returns {string} - a string in base58
+ */
+export function Uint8ArrayTobase58(input) {
+    return bs58.encode(input);
+}
+/**
+ * Count the amount of signatures are not null.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - an array of SignaturePubkeyPair
+ * @returns {number} - the amount of valid signatures
+ */
+export function countNotNullSignatures(signatures) {
+    return signatures.filter((sig) => !!sig.signature).length;
+}
+/**
+ * Check if all signatures are completed.
+ *
+ * @param {SignaturePubkeyPair[]} signatures - signatures
+ * @returns {boolean}
+ */
+export 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.
+ */
+export function matchTransactionTypeByInstructionsOrder(instructions, instructionIndexes) {
+    const instructionsCopy = [...instructions]; // Make a copy since we may modify the array below
+    // AdvanceNonceAccount is optional and the first instruction added, it does not matter to match the type
+    if (instructionsCopy.length > 0) {
+        if (getInstructionType(instructions[0]) === 'AdvanceNonceAccount') {
+            instructionsCopy.shift();
+        }
+    }
+    // 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 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
+ */
+export function getTransactionType(transaction) {
+    const { instructions } = transaction;
+    if (validateRawMsgInstruction(instructions)) {
+        return 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 TransactionType.CustomTx;
+    }
+    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 === ValidInstructionTypesEnum.Transfer && !memoData?.includes('PrepareForRevoke')) ||
+                instructionType === ValidInstructionTypesEnum.TokenTransfer) {
+                return TransactionType.Send;
+            }
+        }
+    }
+    if (matchTransactionTypeByInstructionsOrder(instructions, walletInitInstructionIndexes)) {
+        return TransactionType.WalletInitialization;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, marinadeStakingActivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, jitoStakingActivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, jitoStakingActivateWithATAInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, stakingActivateInstructionsIndexes)) {
+        return TransactionType.StakingActivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, stakingAuthorizeInstructionsIndexes)) {
+        return TransactionType.StakingAuthorize;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, stakingDelegateInstructionsIndexes)) {
+        return TransactionType.StakingDelegate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, marinadeStakingDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, stakingDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, stakingPartialDeactivateInstructionsIndexes) ||
+        matchTransactionTypeByInstructionsOrder(instructions, jitoStakingDeactivateInstructionsIndexes)) {
+        return TransactionType.StakingDeactivate;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, stakingWithdrawInstructionsIndexes)) {
+        return TransactionType.StakingWithdraw;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, ataInitInstructionIndexes)) {
+        return TransactionType.AssociatedTokenAccountInitialization;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, ataCloseInstructionIndexes)) {
+        return TransactionType.CloseAssociatedTokenAccount;
+    }
+    else if (matchTransactionTypeByInstructionsOrder(instructions, ataRecoverNestedInstructionIndexes)) {
+        return TransactionType.CloseAssociatedTokenAccount;
+    }
+    else {
+        return 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
+ */
+export function getInstructionType(instruction) {
+    switch (instruction.programId.toString()) {
+        case new PublicKey(MEMO_PROGRAM_PK).toString():
+            return 'Memo';
+        case SystemProgram.programId.toString():
+            return SystemInstruction.decodeInstructionType(instruction);
+        case TOKEN_PROGRAM_ID.toString():
+        case TOKEN_2022_PROGRAM_ID.toString():
+            const decodedInstruction = decodeInstruction(instruction, instruction.programId);
+            const instructionTypeMap = new Map();
+            instructionTypeMap.set(TokenInstruction.CloseAccount, 'CloseAssociatedTokenAccount');
+            instructionTypeMap.set(TokenInstruction.Burn, 'Burn');
+            instructionTypeMap.set(TokenInstruction.MintTo, 'MintTo');
+            instructionTypeMap.set(TokenInstruction.Approve, 'Approve');
+            instructionTypeMap.set(TokenInstruction.TransferChecked, 'TokenTransfer');
+            const validInstruction = instructionTypeMap.get(decodedInstruction.data.instruction);
+            if (!validInstruction) {
+                return 'CustomInstruction';
+            }
+            return validInstruction;
+        case STAKE_POOL_PROGRAM_ID.toString():
+            const discriminator = instruction.data.readUint8(0);
+            const layoutKey = Object.entries(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 StakeProgram.programId.toString():
+            return StakeInstruction.decodeInstructionType(instruction);
+        case 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 NotSupported('Invalid transaction, instruction program id not supported: ' + instruction.programId.toString());
+            }
+        case COMPUTE_BUDGET:
+            if (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}
+ */
+export function validateIntructionTypes(instructions) {
+    for (const instruction of instructions) {
+        if (!VALID_SYSTEM_INSTRUCTION_TYPES.includes(getInstructionType(instruction))) {
+            throw new 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
+ */
+export 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 === SystemProgram.programId.toString() && programId2 === StakeProgram.programId.toString()) {
+            const instructionName1 = SystemInstruction.decodeInstructionType(instructions[0]);
+            const data = instructions[1].data.toString('hex');
+            if (instructionName1 === nonceAdvanceInstruction &&
+                (data === validInstructionData || data === 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 === SystemProgram.programId.toString() &&
+            programId2 === StakeProgram.programId.toString() &&
+            programId3 === StakeProgram.programId.toString()) {
+            const instructionName1 = SystemInstruction.decodeInstructionType(instructions[0]);
+            const data = instructions[1].data.toString('hex');
+            const data2 = instructions[2].data.toString('hex');
+            if (instructionName1 === nonceAdvanceInstruction &&
+                (data === validInstructionData || data === validInstructionData2) &&
+                (data2 === validInstructionData || data2 === 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
+ */
+export function validateRawTransaction(rawTransaction, requireAllSignatures = false, verifySignatures = false) {
+    if (!rawTransaction) {
+        throw new ParseTransactionError('Invalid raw transaction: Undefined');
+    }
+    if (!isValidRawTransaction(rawTransaction, requireAllSignatures, verifySignatures)) {
+        throw new 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.
+ */
+export function validateAddress(address, fieldName) {
+    if (!address || !isValidPublicKey(address)) {
+        throw new 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
+ */
+export function getSolTokenFromAddress(tokenAddress, network) {
+    const tokens = coins.filter((coin) => {
+        if (coin instanceof 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
+        assert(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
+ */
+export function getSolTokenFromAddressOnly(tokenAddress) {
+    const tokens = coins.filter((coin) => {
+        if (coin instanceof 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
+        assert(tokensArray.length === 1);
+        return tokensArray[0];
+    }
+    return undefined;
+}
+/**
+ * Get the solana token object from token name
+ * @param tokenName The token name to match against
+ * */
+export function getSolTokenFromTokenName(tokenName) {
+    try {
+        const token = coins.get(tokenName);
+        if (!(token.isToken && token instanceof SolCoin)) {
+            return undefined;
+        }
+        return token;
+    }
+    catch (e) {
+        if (!(e instanceof 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
+ * */
+export async function getAssociatedTokenAccountAddress(tokenMintAddress, ownerAddress, allowOwnerOffCurve = false, programId) {
+    const mintPublicKey = new PublicKey(tokenMintAddress);
+    const ownerPublicKey = new PublicKey(ownerAddress);
+    // tokenAddress are not on ed25519 curve, so they can't be used as ownerAddress
+    if (!allowOwnerOffCurve && !PublicKey.isOnCurve(ownerPublicKey.toBuffer())) {
+        throw new UtilsError('Invalid ownerAddress - address off ed25519 curve, got: ' + ownerAddress);
+    }
+    if (!programId) {
+        const coin = getSolTokenFromAddressOnly(tokenMintAddress);
+        if (coin && coin instanceof SolCoin && 'programId' in coin && coin.programId) {
+            programId = coin.programId.toString();
+        }
+        else {
+            programId = TOKEN_PROGRAM_ID.toString();
+        }
+    }
+    let ataAddress;
+    if (programId === TOKEN_2022_PROGRAM_ID.toString()) {
+        ataAddress = await getAssociatedTokenAddress(mintPublicKey, ownerPublicKey, allowOwnerOffCurve, TOKEN_2022_PROGRAM_ID);
+    }
+    else {
+        ataAddress = await getAssociatedTokenAddress(mintPublicKey, ownerPublicKey, allowOwnerOffCurve);
+    }
+    return ataAddress.toString();
+}
+export function validateMintAddress(mintAddress) {
+    if (!mintAddress || !isValidAddress(mintAddress)) {
+        throw new BuildTransactionError('Invalid or missing mintAddress, got: ' + mintAddress);
+    }
+}
+export function validateOwnerAddress(ownerAddress) {
+    if (!ownerAddress || !isValidAddress(ownerAddress)) {
+        throw new 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)
+ */
+export function isSolLegacyInstruction(instruction) {
+    return 'programId' in instruction;
+}
+//# 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  TokenInstruction,\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} 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 is optional and the first instruction added, it does not matter to match the type\n  if (instructionsCopy.length > 0) {\n    if (getInstructionType(instructions[0]) === 'AdvanceNonceAccount') {\n      instructionsCopy.shift();\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 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  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 {\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      const decodedInstruction = decodeInstruction(instruction, instruction.programId);\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 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"]}