Set Compute Units and Priority Fees

Optimize your Solana transactions by setting compute unit limits and priority fees. This helps ensure transactions succeed during network congestion and controls execution costs.

@solana/kit
@solana/web3.js
Anchor

import { useParaSolanaSigner, useParaSolanaSignAndSend } from '@getpara/react-sdk';
import { Address } from '@solana/addresses';
import {
  createSolanaRpc,
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  lamports,
} from '@solana/kit';
import { getTransferSolInstruction } from '@solana-program/system';
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from '@solana-program/compute-budget';

const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

function ComputeUnitsExample() {
  const { solanaSigner, isLoading } = useParaSolanaSigner({ rpc });
  const { signAndSendAsync, isPending } = useParaSolanaSignAndSend(solanaSigner);

  const sendWithPriorityFee = async () => {
    if (!solanaSigner) return;

    const recipient = "RECIPIENT_ADDRESS" as Address;
    const response = await rpc.getLatestBlockhash().send();
    const { blockhash, lastValidBlockHeight } = response.value;

    const { value: recentFees } = await rpc.getRecentPrioritizationFees().send();
    const avgFee = recentFees.reduce((sum, fee) => sum + fee.prioritizationFee, 0n) / BigInt(recentFees.length);
    const priorityFee = (avgFee * 120n) / 100n;

    const transaction = pipe(
      createTransactionMessage({ version: "legacy" }),
      tx => setTransactionMessageFeePayer(solanaSigner.address, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash({ blockhash, lastValidBlockHeight }, tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 200000 }), tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: priorityFee }), tx),
      tx => appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: solanaSigner,
          destination: recipient,
          amount: lamports(100_000_000n),
        }),
        tx
      )
    );

    const result = await signAndSendAsync({ transactions: [transaction] });

    return result;
  };

  return <button onClick={sendWithPriorityFee}>Send with Priority Fee</button>;
}

import { useParaSolana } from './hooks/useParaSolana';
import {
  Transaction,
  SystemProgram,
  LAMPORTS_PER_SOL,
  PublicKey,
  ComputeBudgetProgram
} from '@solana/web3.js';

function ComputeUnitsExample() {
  const { connection, signer } = useParaSolana();

  const sendWithPriorityFee = async () => {
    const recipient = new PublicKey("RECIPIENT_ADDRESS");

    // Get recent prioritization fees
    const recentFees = await connection.getRecentPrioritizationFees();
    const avgFee = recentFees.reduce((sum, fee) => sum + fee.prioritizationFee, 0) / recentFees.length;
    const priorityFee = Math.ceil(avgFee * 1.2); // 20% above average

    const transaction = new Transaction()
      .add(
        // Set compute unit limit
        ComputeBudgetProgram.setComputeUnitLimit({
          units: 200000, // Adjust based on your transaction needs
        })
      )
      .add(
        // Set priority fee
        ComputeBudgetProgram.setComputeUnitPrice({
          microLamports: priorityFee,
        })
      )
      .add(
        // Your actual transaction instruction
        SystemProgram.transfer({
          fromPubkey: signer.sender,
          toPubkey: recipient,
          lamports: LAMPORTS_PER_SOL * 0.1,
        })
      );

    try {
      const signature = await signer.sendTransaction(transaction, {
        skipPreflight: false,
        maxRetries: 3,
      });

      console.log("Transaction sent with priority fee:", signature);
      console.log("Priority fee used:", priorityFee, "microLamports");

      const confirmation = await connection.confirmTransaction(signature, "confirmed");
      console.log("Transaction confirmed:", confirmation);
    } catch (error) {
      console.error("Transaction failed:", error);
    }
  };

  return <button onClick={sendWithPriorityFee}>Send with Priority Fee</button>;
}

Compute unit management works the same as @solana/kit — add compute budget instructions to your transaction:

import { useParaSolanaSigner } from "@getpara/react-sdk";
import { createSolanaRpc } from "@solana/kit";
import { pipe, createTransactionMessage, setTransactionMessageFeePayerSigner,
  setTransactionMessageLifetimeUsingBlockhash, appendTransactionMessageInstruction,
  signAndSendTransactionMessageWithSigners } from "@solana/kit";
import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction } from "@solana-program/compute-budget";
import { getInitializeInstruction } from "./generated/instructions";

const rpc = createSolanaRpc("https://api.devnet.solana.com");

function WithComputeUnits() {
  const { solanaSigner, isLoading } = useParaSolanaSigner({ rpc });

  const execute = async () => {
    if (!solanaSigner) return;

    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();

    const tx = pipe(
      createTransactionMessage({ version: 0 }),
      tx => setTransactionMessageFeePayerSigner(solanaSigner, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 400_000 }), tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: 1000n }), tx),
      tx => appendTransactionMessageInstruction(getInitializeInstruction({ user: solanaSigner }), tx),
    );

    const signature = await signAndSendTransactionMessageWithSigners(tx);
    console.log("Transaction with compute budget:", signature);
  };

  if (isLoading) return <p>Loading...</p>;
  return <button onClick={execute}>Execute with Compute Budget</button>;
}

​Next Steps

Next Steps