Set Compute Units and Priority Fees - Para Docs

You’re viewing the 2.0 (LTS) docs. View the current 3.0 version of this page.

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