Execute Transactions with Solana Libraries

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

const LAMPORTS_PER_SOL = BigInt(1000000000);

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

  const sendSOL = async () => {
    if (!signer) return;

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

    const transferInstruction = getTransferSolInstruction({
      source: signer,
      destination: recipient,
      amount: lamports(LAMPORTS_PER_SOL / 10n),
    });

    const transactionMessage = pipe(
      createTransactionMessage({ version: "legacy" }),
      (tx) => setTransactionMessageFeePayer(signer.address, tx),
      (tx) => setTransactionMessageLifetimeUsingBlockhash({ blockhash, lastValidBlockHeight }, tx),
      (tx) => appendTransactionMessageInstruction(transferInstruction, 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();

    let confirmed = false;
    while (!confirmed) {
      const status = await rpc.getSignatureStatuses([txSignature], {
        searchTransactionHistory: true,
      }).send();
      if (status?.value?.[0]?.confirmationStatus === "confirmed" ||
          status?.value?.[0]?.confirmationStatus === "finalized") {
        confirmed = true;
      }
      if (!confirmed) await new Promise(r => setTimeout(r, 500));
    }
  };

  return <button onClick={sendSOL}>Send 0.1 SOL</button>;
}

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

function AnchorTransaction() {
  const provider = useParaAnchor();
  
  const executeProgram = async () => {
    if (provider.wallet.publicKey.equals(SystemProgram.programId)) {
      console.error("No wallet connected. Please authenticate first.");
      return;
    }
    
    anchor.setProvider(provider);
    const program = new anchor.Program(idl, provider);
    
    try {
      const tx = await program.methods
        .initialize()
        .accounts({
          user: provider.publicKey,
          systemProgram: SystemProgram.programId,
        })
        .rpc();
        
      console.log("Transaction signature:", tx);
      
      const confirmation = await provider.connection.confirmTransaction(tx, "confirmed");
      console.log("Transaction confirmed:", confirmation);
    } catch (error) {
      console.error("Transaction failed:", error);
    }
  };
  
  return <button onClick={executeProgram}>Execute Program</button>;
}