getTransaction

​

参数

​

响应

​

代码示例

​

基本请求

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

​

使用 web3.js

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

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// 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
      }
    }
  };
}

​

注意事项

1. 返回给定签名的交易详情
2. 交易必须已确认才会返回
3. 响应包含交易的详细信息
4. 可以使用不同的编码格式解析交易
5. 签名必须是有效的交易签名

​

最佳实践

1. 根据需求使用适当的 commitment 级别
2. 在适当时缓存结果以减少 RPC 负载
3. 监控交易状态变化
4. 考虑使用 WebSocket 订阅获取实时更新
5. 适当处理网络错误并重试

​

常见错误

​

用例

1. 交易分析
   复制

   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;
       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]
           })),
           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),
           instructionCount: transaction.transaction.message.instructions.length,
           accountCount: transaction.transaction.message.accountKeys.length
         },
         metadata: {
           timestamp: Date.now(),
           commitment: config.commitment
         }
       };
     }
   }
   
2. 交易监控
   复制

   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;
     }
   }