can anyone help me increase solana transaction fee? or increase transaction speed

Question

here is my codes

async sendSplTransaction(wallet, {to, value, mintAddress, decimals, fee}) {
    const recipientPubKey = new PublicKey(to);
    const mintPubKey = new PublicKey(mintAddress);
    const bigValue = this.convertToBigInt(value, decimals);
    const recentBlockhash = await this.provider.connection.getLatestBlockhash();
    let currentBlockheight = await this.provider.connection.getBlockHeight();
    const { blockhash } = await this.provider.connection.getLatestBlockhash();
    const MAX_RETRIES = 3;
    let retryCount = 0;

    while (retryCount < MAX_RETRIES) {
        try {
            const senderATA = await getAssociatedTokenAddress(mintPubKey, this.keypair.publicKey);
            const recipientATA = await getAssociatedTokenAddress(mintPubKey, recipientPubKey);

            console.log('Sender pubkey:', this.keypair.publicKey.toString());
            console.log('Sender ATA:', senderATA.toString());
            console.log('Mint address:', mintAddress);

            let senderAccountInfo =  await this.provider.connection.getAccountInfo(senderATA);

            if (!senderAccountInfo) {
                console.log('Sender ATA not found. Attempting to create...');
                const transaction = new Transaction().add(
                    createAssociatedTokenAccountInstruction(
                        this.keypair.publicKey,
                        senderATA,
                        this.keypair.publicKey,
                        mintPubKey
                    )
                );
                await solanaWeb3.sendAndConfirmTransaction(this.provider.connection, transaction, [this.keypair]);
                console.log('Sender ATA created successfully');
            }

            const senderBalance = await this.provider.connection.getTokenAccountBalance(senderATA);
            console.log('Sender token balance:', senderBalance.value.uiAmount);

            if (senderBalance.value.uiAmount < value) {
                throw new Error(`Insufficient balance. Current balance: ${senderBalance.value.uiAmount}`);
            }

            const transaction = new Transaction({
                recentBlockhash: recentBlockhash.blockhash,
                feePayer: this.keypair.publicKey
            });
            transaction.recentBlockhash = blockhash;
            transaction.feePayer = this.keypair.publicKey;
            transaction.fee = fee;

            const recipientAccountInfo = await this.provider.connection.getAccountInfo(recipientATA);

            if (!recipientAccountInfo) {
                transaction.add(
                    createAssociatedTokenAccountInstruction(
                        this.keypair.publicKey,
                        recipientATA,
                        recipientPubKey,
                        mintPubKey
                    )
                );
            }

            transaction.add(
                createTransferInstruction(
                    senderATA,
                    recipientATA,
                    this.keypair.publicKey,
                    bigValue,
                    [],
                    TOKEN_PROGRAM_ID
                )
            );

            transaction.lastValidBlockHeight = currentBlockheight + 150;

            const txid = await solanaWeb3.sendAndConfirmTransaction(
                this.provider.connection,
                transaction,
                [this.keypair],
                {
                    commitment: "confirmed",
                    skipPreflight: true
                }
            );

            console.log('Transaction successful. Txid:', txid);
            return { success: true, data: { txid } };
        } catch (error) {
            if (error.message.includes('block height')) {
                retryCount++;
                const MAX_RETRY_DELAY = 30000;
                const delay = Math.min(2 ** retryCount * 1000, MAX_RETRY_DELAY);
                console.log(`Transaction failed, retrying in ${delay / 1000} seconds...`);
                await new Promise(resolve => setTimeout(resolve, delay));
            } else {
                return { success: false, data: null, error: error.message };
            }
        }
    }

    return { success: false, data: null, error: 'Transaction retries exhausted.' };
}

Answer 1

Some areas you could try troubleshooting with are,

1. Experiment with different RPC providers. Chainstack and triton.one are good ones to start with.

2. Try adding a priority fee instruction.

The code below

async function recentPriorityFees() {
    const url =
        "https://nd-326-444-187.p2pify.com/9de47db917d4f69168e3fed02217d15b/";
    const options = {
        method: "POST",
        headers: {
            accept: "application/json",
            "content-type": "application/json",
        },
        body: JSON.stringify({
            id: 1,
            jsonrpc: "2.0",
            method: "getRecentPrioritizationFees",
            params: [["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"]],
        }),
    };
    let resp = (await (await fetch(url, options)).json()) as any;
    return resp.result[0].prioritizationFee;
}


// ----- snip 

const recentFee = await recentPriorityFees();
const PRIORITY_FEE_INSTRUCTIONS = ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: recentFee,
});

transaction.add(
                createTransferInstruction(
                    senderATA,
                    recipientATA,
                    this.keypair.publicKey,
                    bigValue,
                    [],
                    TOKEN_PROGRAM_ID
                )
            ).add(PRIORITY_FEE_INSTRUCTIONS);

// ---- snip

If you prefer UMI, here's how to use it's inbuild RPC plugin to make the call to fetch the fees for Ore

async function fetchRecentPriorityFees() {
    return (await umi.rpc.call("getRecentPrioritizationFees", [
        ["oreV2ZymfyeXgNgBdqMkumTqqAprVqgBWQfoYkrtKWQ"],
    ])) as any;
}

fetchRecentPriorityFees()
    .then((res) => console.log(res[0].prioritizationFee))
    .catch(console.error);