> ## 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.

# Get Solana Transaction Status

> Check transaction confirmation status and finality on Solana

Monitor transaction confirmation status and wait for finality on Solana. This guide covers checking transaction results and understanding commitment levels.

<Card title="Setup Solana Libraries First" description="Configure Solana libraries with Para SDK before using these operations" href="/v3/react-native/guides/web3-operations/solana/setup-libraries" horizontal />

<Tabs>
  <Tab title="@solana/kit">
    ```typescript theme={null}
    import { useParaSolanaSigner } from "@getpara/react-native-wallet/solana";
    import { createSolanaRpc, Signature, Commitment } from '@solana/kit';

    const rpc = createSolanaRpc("https://api.mainnet-beta.solana.com");

    function TransactionStatus() {
      const { solanaSigner, isLoading } = useParaSolanaSigner({ rpc });

      const checkTransactionStatus = async (signature: Signature) => {
        try {
          const { value: statuses } = await rpc
            .getSignatureStatuses([signature], { searchTransactionHistory: true })
            .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();

          let confirmed = false;
          while (!confirmed) {
            const { value: statuses } = await rpc
              .getSignatureStatuses([signature], { searchTransactionHistory: true })
              .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>
      );
    }
    ```
  </Tab>

  <Tab title="@solana/web3.js">
    ```typescript theme={null}
    import { useParaSolana } from './hooks/useParaSolana';
    import { TransactionSignature, Commitment } from '@solana/web3.js';

    function TransactionStatus() {
      const { connection } = useParaSolana();

      const checkTransactionStatus = async (signature: string) => {
        try {
          // Get signature status
          const status = await connection.getSignatureStatus(signature);

          if (status.value === null) {
            console.log("Transaction not found");
            return null;
          }

          console.log("Confirmations:", status.value.confirmations || "Max (32+)");
          console.log("Confirmation status:", status.value.confirmationStatus);
          console.log("Slot:", status.value.slot);

          if (status.value.err) {
            console.error("Transaction failed:", status.value.err);
            return false;
          }

          return status.value.confirmationStatus;
        } catch (error) {
          console.error("Error checking status:", error);
          throw error;
        }
      };

      const waitForConfirmation = async (
        signature: string,
        commitment: Commitment = 'confirmed'
      ) => {
        try {
          const startTime = Date.now();

          // Wait for confirmation with timeout
          const confirmation = await connection.confirmTransaction(
            signature,
            commitment
          );

          const elapsed = Date.now() - startTime;
          console.log(`Transaction confirmed in ${elapsed}ms`);

          if (confirmation.value.err) {
            throw new Error(`Transaction failed: ${confirmation.value.err}`);
          }

          // Get detailed transaction info
          const txInfo = await connection.getTransaction(signature, {
            commitment,
            maxSupportedTransactionVersion: 0,
          });

          if (txInfo) {
            console.log("Block time:", new Date(txInfo.blockTime! * 1000));
            console.log("Fee:", txInfo.meta?.fee, "lamports");
            console.log("Compute units consumed:", txInfo.meta?.computeUnitsConsumed);
          }

          return txInfo;
        } catch (error) {
          console.error("Confirmation error:", error);
          throw error;
        }
      };

      return (
        <div>
          <button onClick={() => checkTransactionStatus("YOUR_SIGNATURE")}>
            Check Status
          </button>
          <button onClick={() => waitForConfirmation("YOUR_SIGNATURE", "finalized")}>
            Wait for Finalization
          </button>
        </div>
      );
    }
    ```
  </Tab>

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

## Next Steps

<CardGroup cols={3}>
  <Card title="Execute Transactions" description="Send transactions to monitor" href="/v3/react-native/guides/web3-operations/solana/execute-transactions" icon="bolt" />

  <Card title="Compute Units" description="Optimize transaction success rates" href="/v3/react-native/guides/web3-operations/solana/compute-units" icon="calculator" />

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