getTransaction

​

Parameters

​

Response

​

Code Examples

​

Basic Request

curl https://rpc.orbitflare.com -X POST -H "Content-Type: application/json" -d '{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getTransaction",
  "params": [
    "5VERv8NMvzbJMEkV8xnrLkUaQwJJ9C9zV5uZ6cKf7Kq9",
    {
      "encoding": "jsonParsed"
    }
  ]
}'

​

Using web3.js

import { Connection, Transaction } from '@solana/web3.js';

const connection = new Connection('https://rpc.orbitflare.com');

// Get transaction
const signature = '5VERv8NMvzbJMEkV8xnrLkUaQwJJ9C9zV5uZ6cKf7Kq9';
const transaction = await connection.getTransaction(signature, {
  encoding: 'jsonParsed'
});
console.log('Transaction:', transaction);

// Get transaction with analysis
async function getTransactionWithAnalysis(
  signature: string,
  config: { commitment?: string; encoding?: string }
) {
  const transaction = await connection.getTransaction(signature, config);
  
  return {
    transaction,
    analysis: {
      success: !transaction.meta.err,
      fee: transaction.meta.fee,
      balanceChanges: transaction.meta.postBalances.map((post, index) => ({
        account: transaction.transaction.message.accountKeys[index],
        change: post - transaction.meta.preBalances[index]
      })),
      tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
        account: post.account,
        mint: post.mint,
        change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
      })),
      metadata: {
        timestamp: Date.now(),
        commitment: config.commitment
      }
    }
  };
}

​

Notes

1. Returns transaction details for a given signature
2. The transaction must be confirmed to be returned
3. The response includes detailed information about the transaction
4. The transaction can be parsed in different encodings
5. The transaction must be a valid signature

​

Best Practices

1. Use appropriate commitment level based on your needs
2. Cache results when appropriate to reduce RPC load
3. Monitor for transaction status changes
4. Consider using websocket subscription for real-time updates
5. Handle network errors and retry when appropriate

​

Common Errors

​

Use Cases

1. Transaction Analysis

   interface TransactionAnalysis {
     signature: string;
     transaction: {
       success: boolean;
       fee: number;
       balanceChanges: Array<{
         account: string;
         change: number;
       }>;
       tokenBalanceChanges?: Array<{
         account: string;
         mint: string;
         change: bigint;
       }>;
       instructions: Array<{
         programId: string;
         accounts: string[];
         data: string;
       }>;
     };
     metrics: {
       totalBalanceChange: number;
       totalTokenBalanceChange?: bigint;
       instructionCount: number;
       accountCount: number;
     };
     metadata: {
       timestamp: number;
       commitment?: string;
     };
   }
   
   class TransactionAnalyzer {
     async analyzeTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionAnalysis> {
       const transaction = await connection.getTransaction(signature, config);
       
       return {
         signature,
         transaction: {
           success: !transaction.meta.err,
           fee: transaction.meta.fee,
           balanceChanges: transaction.meta.postBalances.map((post, index) => ({
             account: transaction.transaction.message.accountKeys[index],
             change: post - transaction.meta.preBalances[index]
           })),
           tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
             account: post.account,
             mint: post.mint,
             change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
           })),
           instructions: transaction.transaction.message.instructions.map(ix => ({
             programId: transaction.transaction.message.accountKeys[ix.programIdIndex],
             accounts: ix.accounts.map(index => transaction.transaction.message.accountKeys[index]),
             data: ix.data
           }))
         },
         metrics: {
           totalBalanceChange: transaction.meta.postBalances.reduce((sum, post, index) => 
             sum + (post - transaction.meta.preBalances[index]), 0),
           totalTokenBalanceChange: transaction.meta.postTokenBalances?.reduce((sum, post, index) => 
             sum + (BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)), BigInt(0)),
           instructionCount: transaction.transaction.message.instructions.length,
           accountCount: transaction.transaction.message.accountKeys.length
         },
         metadata: {
           timestamp: Date.now(),
           commitment: config.commitment
         }
       };
     }
   }
   

2. Transaction Monitoring

   interface TransactionChange {
     signature: string;
     changes: {
       status: 'confirmed' | 'failed' | 'dropped';
       previousStatus?: 'confirmed' | 'failed' | 'dropped';
       error?: any;
     };
     metadata: {
       timestamp: number;
     };
   }
   
   class TransactionMonitor {
     private previousTransactions: Map<string, {
       status: 'confirmed' | 'failed' | 'dropped';
       error?: any;
     }> = new Map();
     
     async monitorTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionChange | null> {
       const transaction = await connection.getTransaction(signature, config);
       const currentStatus = transaction ? (transaction.meta.err ? 'failed' : 'confirmed') : 'dropped';
       const previous = this.previousTransactions.get(signature);
       
       if (previous && (previous.status !== currentStatus || previous.error !== transaction?.meta.err)) {
         this.previousTransactions.set(signature, {
           status: currentStatus,
           error: transaction?.meta.err
         });
         
         return {
           signature,
           changes: {
             status: currentStatus,
             previousStatus: previous.status,
             error: transaction?.meta.err
           },
           metadata: {
             timestamp: Date.now()
           }
         };
       }
       
       this.previousTransactions.set(signature, {
         status: currentStatus,
         error: transaction?.meta.err
       });
       return null;
     }
   }
   

3. Transaction Planning

   interface TransactionPlan {
     signature: string;
     transaction: {
       success: boolean;
       fee: number;
       balanceChanges: Array<{
         account: string;
         change: number;
       }>;
       tokenBalanceChanges?: Array<{
         account: string;
         mint: string;
         change: bigint;
       }>;
     };
     recommendations: Array<{
       type: 'optimize' | 'retry' | 'cancel';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }
   
   class TransactionPlanner {
     private readonly maxFee = 1000000; // 0.001 SOL
     private readonly minBalance = 1000000; // 0.001 SOL
     
     async planTransaction(
       signature: string,
       config: { commitment?: string; encoding?: string }
     ): Promise<TransactionPlan> {
       const transaction = await connection.getTransaction(signature, config);
       
       const recommendations: Array<{
         type: 'optimize' | 'retry' | 'cancel';
         reason: string;
       }> = [];
       
       // Check for high fees
       if (transaction.meta.fee > this.maxFee) {
         recommendations.push({
           type: 'optimize',
           reason: `Transaction fee (${transaction.meta.fee}) exceeds maximum (${this.maxFee})`
         });
       }
       
       // Check for low balances
       const lowBalanceAccounts = transaction.meta.postBalances
         .map((post, index) => ({
           account: transaction.transaction.message.accountKeys[index],
           balance: post
         }))
         .filter(acc => acc.balance < this.minBalance);
       
       if (lowBalanceAccounts.length > 0) {
         recommendations.push({
           type: 'optimize',
           reason: `Accounts with low balances: ${lowBalanceAccounts.map(acc => acc.account).join(', ')}`
         });
       }
       
       // Check for failed transaction
       if (transaction.meta.err) {
         recommendations.push({
           type: 'retry',
           reason: `Transaction failed with error: ${JSON.stringify(transaction.meta.err)}`
         });
       }
       
       return {
         signature,
         transaction: {
           success: !transaction.meta.err,
           fee: transaction.meta.fee,
           balanceChanges: transaction.meta.postBalances.map((post, index) => ({
             account: transaction.transaction.message.accountKeys[index],
             change: post - transaction.meta.preBalances[index]
           })),
           tokenBalanceChanges: transaction.meta.postTokenBalances?.map((post, index) => ({
             account: post.account,
             mint: post.mint,
             change: BigInt(post.uiTokenAmount.amount) - BigInt(transaction.meta.preTokenBalances![index].uiTokenAmount.amount)
           }))
         },
         recommendations,
         metadata: {
           timestamp: Date.now()
         }
       };
     }
   }