Set Compute Units and Priority Fees

import { useParaSolanaV2 } from './hooks/useParaSolanaV2';
import { 
  pipe,
  createTransactionMessage,
  setTransactionMessageFeePayer,
  setTransactionMessageLifetimeUsingBlockhash,
  appendTransactionMessageInstruction,
  getSystemInstruction,
  getSetComputeUnitLimitInstruction,
  getSetComputeUnitPriceInstruction,
  address,
  lamports
} from '@solana/web3.js';

function ComputeUnitsExample() {
  const { rpc, signer } = useParaSolanaV2();
  
  const sendWithPriorityFee = async () => {
    const recipient = address("RECIPIENT_ADDRESS");
    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
    
    // Get recent prioritization fees
    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; // 20% above average
    
    const transaction = pipe(
      createTransactionMessage({ version: 0 }),
      tx => setTransactionMessageFeePayer(signer.address, tx),
      tx => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, tx),
      tx => appendTransactionMessageInstruction(
        getSetComputeUnitLimitInstruction({
          units: 200000,
        }),
        tx
      ),
      tx => appendTransactionMessageInstruction(
        getSetComputeUnitPriceInstruction({
          microLamports: priorityFee,
        }),
        tx
      ),
      tx => appendTransactionMessageInstruction(
        getSystemInstruction({
          amount: lamports(100_000_000n),
          destination: recipient,
          source: signer.address,
        }),
        tx
      )
    );
    
    try {
      const [signature] = await signer.signAndSendTransactions([transaction]);
      console.log("Transaction sent with priority fee:", signature);
      console.log("Priority fee used:", priorityFee.toString(), "microLamports");
      
      const status = await rpc.getSignatureStatuses([signature]).send();
      console.log("Transaction status:", status);
    } catch (error) {
      console.error("Transaction failed:", error);
    }
  };
  
  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 '@project-serum/anchor';

function ComputeUnitsExample() {
  const provider = useParaAnchor();
  
  const sendWithPriorityFee = async () => {
    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>;
}