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. Используйте подходящий уровень подтверждения в зависимости от ваших потребностей
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;
       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. Мониторинг транзакций
   Копировать

   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. Планирование транзакций
   Копировать

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