@terminusbet/stake-vote-sdk/dist/esm/util.js

A simple SDK for interacting with terminusbet governance

import { ComputeBudgetProgram, SendTransactionError, Transaction, TransactionMessage, VersionedTransaction, } from "@solana/web3.js";
import { getAssociatedTokenAddressSync } from "@solana/spl-token";
export const DEFAULT_COMMITMENT = "confirmed";
export const DEFAULT_FINALITY = "confirmed";
export async function simulateMethodCall(connection, payer, transaction) {
    const versionedTransaction = await buildVersionedTx(connection, payer, transaction, [], 'confirmed');
    return await connection.simulateTransaction(versionedTransaction);
}
export async function sendTx(connection, tx, payer, signers, priorityFees, addressLookupTableAccounts = [], commitment = DEFAULT_COMMITMENT, finality = DEFAULT_FINALITY) {
    let newTx = new Transaction();
    if (priorityFees) {
        const modifyComputeUnits = ComputeBudgetProgram.setComputeUnitLimit({
            units: priorityFees.unitLimit,
        });
        const addPriorityFee = ComputeBudgetProgram.setComputeUnitPrice({
            microLamports: priorityFees.unitPrice,
        });
        newTx.add(modifyComputeUnits);
        newTx.add(addPriorityFee);
    }
    newTx.add(tx);
    const latestBlockhash = (await connection.getLatestBlockhash(commitment));
    let versionedTx = await buildVersionedTx(connection, payer, newTx, addressLookupTableAccounts, commitment, latestBlockhash);
    versionedTx.sign(signers);
    try {
        const sig = await connection.sendTransaction(versionedTx, {
            skipPreflight: false,
            preflightCommitment: commitment,
            maxRetries: 3
        });
        console.log("sig:", `https://solscan.io/tx/${sig}`);
        // sleep for 3 seconds to allow the transaction to be processed
        // console.log("Waiting for confirmation......");
        await new Promise(resolve => setTimeout(resolve, 1000));
        let txResult = await getTxDetails(connection, sig, commitment, finality, latestBlockhash);
        if (!txResult) {
            return {
                success: false,
                error: "Transaction failed",
            };
        }
        return {
            success: true,
            signature: sig,
            results: txResult,
        };
    }
    catch (e) {
        if (e instanceof SendTransactionError) {
            let ste = e;
            console.log("SendTransactionError=>" + await ste.getLogs(connection));
        }
        else {
            console.error("GotTxDetails other error=>", e);
        }
        return {
            error: e,
            success: false,
        };
    }
}
export async function buildVersionedTx(connection, payer, tx, lookupTable = [], commitment = DEFAULT_COMMITMENT, opt) {
    if (!opt?.blockhash) {
        opt = await connection.getLatestBlockhash(commitment);
    }
    let messageV0 = new TransactionMessage({
        payerKey: payer,
        recentBlockhash: opt.blockhash,
        instructions: tx.instructions,
    }).compileToV0Message(lookupTable);
    return new VersionedTransaction(messageV0);
}
;
export async function getTxDetails(connection, sig, commitment = DEFAULT_COMMITMENT, finality = DEFAULT_FINALITY, opt) {
    if (!opt?.blockhash) {
        opt = await connection.getLatestBlockhash();
    }
    await connection.confirmTransaction({
        blockhash: opt.blockhash,
        lastValidBlockHeight: opt.lastValidBlockHeight,
        signature: sig,
    }, commitment);
    return connection.getTransaction(sig, {
        maxSupportedTransactionVersion: 0,
        commitment: finality,
    });
}
;
export async function confirmTransaction(connection, signature, desiredConfirmationStatus = 'confirmed', timeout = 60000, pollInterval = 1000, searchTransactionHistory = false) {
    const start = Date.now();
    console.log("signature:", signature);
    while (Date.now() - start < timeout) {
        const { value: statuses } = await connection.getSignatureStatuses([signature], { searchTransactionHistory });
        console.log("statuses:", statuses);
        if (!statuses || statuses.length === 0) {
            throw new Error('Failed to get signature status');
        }
        const status = statuses[0];
        if (status === null) {
            // If status is null, the transaction is not yet known
            await new Promise(resolve => setTimeout(resolve, pollInterval));
            continue;
        }
        if (status.err) {
            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
        }
        if (status.confirmationStatus && status.confirmationStatus === desiredConfirmationStatus) {
            return status;
        }
        if (status.confirmationStatus === 'finalized') {
            return status;
        }
        await new Promise(resolve => setTimeout(resolve, pollInterval));
    }
    return {
        slot: 0,
        confirmations: 0,
        err: new Error(`Transaction confirmation timeout after ${timeout}ms`),
        confirmationStatus: "processed"
    };
}
export const getSPLBalance = async (connection, mintAddress, pubKey, allowOffCurve = false) => {
    try {
        let ata = getAssociatedTokenAddressSync(mintAddress, pubKey, allowOffCurve);
        const balance = await connection.getTokenAccountBalance(ata, "processed");
        return balance.value.uiAmount;
    }
    catch (e) {
        console.log("[getSPLBalance]", e);
    }
    return null;
};
//# sourceMappingURL=util.js.map