Get Solana Transaction Status

import { useParaSolanaV2 } from './hooks/useParaSolanaV2';
import { Signature, Commitment } from '@solana/web3.js';

function TransactionStatus() {
  const { rpc } = useParaSolanaV2();
  
  const checkTransactionStatus = async (signature: Signature) => {
    try {
      // Get multiple signature statuses
      const { value: statuses } = await rpc
        .getSignatureStatuses([signature])
        .send();
      
      const status = statuses[0];
      
      if (!status) {
        console.log("Transaction not found");
        return null;
      }
      
      console.log("Confirmations:", status.confirmations || "Max (32+)");
      console.log("Confirmation status:", status.confirmationStatus);
      console.log("Slot:", status.slot);
      
      if (status.err) {
        console.error("Transaction failed:", status.err);
        return false;
      }
      
      return status;
    } catch (error) {
      console.error("Error checking status:", error);
      throw error;
    }
  };
  
  const waitForConfirmation = async (
    signature: Signature,
    commitment: Commitment = 'confirmed'
  ) => {
    try {
      const startTime = Date.now();
      
      // Poll for confirmation
      let confirmed = false;
      while (!confirmed) {
        const { value: statuses } = await rpc
          .getSignatureStatuses([signature])
          .send();
        
        const status = statuses[0];
        
        if (status?.confirmationStatus === commitment || 
            status?.confirmationStatus === 'finalized') {
          confirmed = true;
          
          if (status.err) {
            throw new Error(`Transaction failed: ${JSON.stringify(status.err)}`);
          }
        }
        
        // Wait before next poll
        if (!confirmed) {
          await new Promise(resolve => setTimeout(resolve, 1000));
        }
        
        // Timeout after 30 seconds
        if (Date.now() - startTime > 30000) {
          throw new Error('Transaction confirmation timeout');
        }
      }
      
      const elapsed = Date.now() - startTime;
      console.log(`Transaction confirmed in ${elapsed}ms`);
      
      // Get transaction details
      const { value: txInfo } = await rpc
        .getTransaction(signature, {
          commitment,
          maxSupportedTransactionVersion: 0,
        })
        .send();
      
      if (txInfo) {
        console.log("Block time:", new Date(txInfo.blockTime * 1000));
        console.log("Fee:", txInfo.meta.fee, "lamports");
        console.log("Compute units:", txInfo.meta.computeUnitsConsumed);
      }
      
      return txInfo;
    } catch (error) {
      console.error("Confirmation error:", error);
      throw error;
    }
  };
  
  return (
    <div>
      <button onClick={() => checkTransactionStatus("YOUR_SIGNATURE" as Signature)}>
        Check Status
      </button>
      <button onClick={() => waitForConfirmation("YOUR_SIGNATURE" as Signature, "finalized")}>
        Wait for Finalization
      </button>
    </div>
  );
}

import { useParaAnchor } from './hooks/useParaAnchor';
import { TransactionSignature, Commitment } from '@solana/web3.js';

function TransactionStatus() {
  const provider = useParaAnchor();
  
  const checkTransactionStatus = async (signature: string) => {
    try {
      const status = await provider.connection.getSignatureStatus(signature);
      
      if (status.value === null) {
        console.log("Transaction not found");
        return null;
      }
      
      console.log("Status:", status.value);
      
      // For Anchor program errors, decode the logs
      if (status.value.err) {
        const tx = await provider.connection.getTransaction(signature, {
          commitment: 'confirmed',
        });
        
        if (tx?.meta?.logMessages) {
          console.log("Transaction logs:");
          tx.meta.logMessages.forEach(log => console.log(log));
          
          // Parse Anchor errors from logs
          const anchorError = tx.meta.logMessages.find(log => 
            log.includes('Program log: AnchorError')
          );
          if (anchorError) {
            console.error("Anchor error found:", anchorError);
          }
        }
        
        return false;
      }
      
      return status.value.confirmationStatus;
    } catch (error) {
      console.error("Error checking status:", error);
      throw error;
    }
  };
  
  const waitForAnchorTransaction = async (
    signature: string,
    commitment: Commitment = 'confirmed'
  ) => {
    try {
      // Use provider's built-in confirmation
      await provider.connection.confirmTransaction(signature, commitment);
      
      // Get parsed transaction
      const tx = await provider.connection.getParsedTransaction(signature, {
        commitment,
        maxSupportedTransactionVersion: 0,
      });
      
      if (!tx) {
        throw new Error('Transaction not found');
      }
      
      if (tx.meta?.err) {
        // Extract error details
        console.error("Transaction error:", tx.meta.err);
        
        if (tx.meta.logMessages) {
          console.log("Error logs:");
          tx.meta.logMessages.forEach(log => console.log(log));
        }
        
        throw new Error('Transaction failed');
      }
      
      console.log("Transaction successful");
      console.log("Fee:", tx.meta?.fee, "lamports");
      console.log("Compute units:", tx.meta?.computeUnitsConsumed);
      
      return tx;
    } catch (error) {
      console.error("Confirmation error:", error);
      throw error;
    }
  };
  
  return (
    <div>
      <button onClick={() => checkTransactionStatus("YOUR_SIGNATURE")}>
        Check Status
      </button>
      <button onClick={() => waitForAnchorTransaction("YOUR_SIGNATURE", "finalized")}>
        Wait for Finalization
      </button>
    </div>
  );
}