Set Compute Units and Priority Fees

import { useParaSolanaKit } from './hooks/useParaSolanaKit';
import { Address } from '@solana/addresses';
import {
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  lamports,
} from '@solana/kit';
import { compileTransaction, getBase64EncodedWireTransaction } from '@solana/transactions';
import { getTransferSolInstruction } from '@solana-program/system';
import {
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
} from '@solana-program/compute-budget';

function ComputeUnitsExample() {
  const { rpc, signer } = useParaSolanaKit();

  const sendWithPriorityFee = async () => {
    if (!signer) 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 transactionMessage = pipe(
      createTransactionMessage({ version: "legacy" }),
      tx => setTransactionMessageFeePayer(signer.address, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash({ blockhash, lastValidBlockHeight }, tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitLimitInstruction({ units: 200000 }), tx),
      tx => appendTransactionMessageInstruction(getSetComputeUnitPriceInstruction({ microLamports: priorityFee }), tx),
      tx => appendTransactionMessageInstruction(
        getTransferSolInstruction({
          source: signer,
          destination: recipient,
          amount: lamports(100_000_000n),
        }),
        tx
      )
    );

    const tx = compileTransaction(transactionMessage);
    const signedTxs = await signer.modifyAndSignTransactions([tx]);
    const serializedTx = getBase64EncodedWireTransaction(signedTxs[0]);

    const txSignature = await rpc.sendTransaction(serializedTx, {
      encoding: "base64",
      skipPreflight: false,
      preflightCommitment: "processed",
    }).send();

    const status = await rpc.getSignatureStatuses([txSignature], {
      searchTransactionHistory: true,
    }).send();

    return { txSignature, status };
  };

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

import { useParaAnchor } from './hooks/useParaAnchor';
import { 
  Transaction, 
  SystemProgram, 
  LAMPORTS_PER_SOL, 
  PublicKey,
  ComputeBudgetProgram 
} from '@solana/web3.js';
import * as anchor from '@coral-xyz/anchor';

function ComputeUnitsExample() {
  const provider = useParaAnchor();
  
  const sendWithPriorityFee = async () => {
    anchor.setProvider(provider);
    const program = new anchor.Program(idl, provider);
    
    // Get recent prioritization fees
    const recentFees = await provider.connection.getRecentPrioritizationFees();
    const avgFee = recentFees.reduce((sum, fee) => sum + fee.prioritizationFee, 0) / recentFees.length;
    const priorityFee = Math.ceil(avgFee * 1.2);
    
    // Create the main instruction
    const ix = await program.methods
      .someMethod()
      .accounts({
        user: provider.publicKey,
        // ... other accounts
      })
      .instruction();
    
    // Build transaction with compute budget instructions
    const transaction = new Transaction()
      .add(
        ComputeBudgetProgram.setComputeUnitLimit({
          units: 300000, // Higher for complex program calls
        })
      )
      .add(
        ComputeBudgetProgram.setComputeUnitPrice({
          microLamports: priorityFee,
        })
      )
      .add(ix);
    
    try {
      const signature = await provider.sendAndConfirm(transaction);
      console.log("Transaction sent with priority fee:", signature);
      console.log("Priority fee used:", priorityFee, "microLamports");
    } catch (error) {
      console.error("Transaction failed:", error);
    }
  };
  
  return <button onClick={sendWithPriorityFee}>Execute with Priority</button>;
}