> ## Documentation Index
> Fetch the complete documentation index at: https://docs.getpara.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Set Compute Units and Priority Fees

> Configure compute budget and priority fees for Solana transactions

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

<Card title="Setup Solana Libraries First" description="You must complete the Solana library setup before configuring compute units" href="/v3/react/guides/web3-operations/solana/setup-libraries" horizontal />

<Tabs>
  <Tab title="@solana/kit">
    ```typescript theme={null}
    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>;
    }
    ```
  </Tab>

  <Tab title="@solana/web3.js">
    ```typescript theme={null}
    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>;
    }
    ```
  </Tab>

  <Tab title="Anchor">
    Compute unit management works the same as @solana/kit — add compute budget instructions to your transaction:

    ```typescript theme={null}
    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>;
    }
    ```
  </Tab>
</Tabs>

## Next Steps

<CardGroup cols={3}>
  <Card title="Execute Transactions" description="Build and send transactions" href="/v3/react/guides/web3-operations/solana/execute-transactions" icon="bolt" />

  <Card title="Get Transaction Status" description="Monitor transaction confirmations" href="/v3/react/guides/web3-operations/solana/get-transaction-status" icon="clock" />

  <Card title="Configure RPC" description="Set up custom RPC endpoints" href="/v3/react/guides/web3-operations/solana/configure-rpc" icon="server" />
</CardGroup>