getTransactionCount

​

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": "getTransactionCount"
}'

​

Using web3.js

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

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

// Get transaction count
const count = await connection.getTransactionCount();
console.log('Transaction count:', count);

// Get transaction count with analysis
async function getTransactionCountWithAnalysis(
  config: { commitment?: string }
) {
  const count = await connection.getTransactionCount(config);
  
  return {
    count,
    analysis: {
      timestamp: Date.now(),
      commitment: config.commitment
    }
  };
}

​

Notes

1. Returns the current transaction count from the ledger
2. The count includes all transactions processed by the node
3. The response is immediate as it reads from the current state
4. The count can change with new transactions
5. The count may vary between nodes due to network propagation

​

Best Practices

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

​

Common Errors

​

Use Cases

1. Transaction Count Analysis
   Copy

   interface TransactionCountAnalysis {
     count: number;
     metrics: {
       timestamp: number;
       commitment?: string;
     };
   }
   
   class TransactionCountAnalyzer {
     async analyzeTransactionCount(
       config: { commitment?: string }
     ): Promise<TransactionCountAnalysis> {
       const count = await connection.getTransactionCount(config);
       
       return {
         count,
         metrics: {
           timestamp: Date.now(),
           commitment: config.commitment
         }
       };
     }
   }
   

2. Transaction Count Monitoring
   Copy

   interface TransactionCountChange {
     changes: {
       previousCount: number;
       currentCount: number;
       difference: number;
       percentageChange: number;
     };
     metadata: {
       timestamp: number;
     };
   }
   
   class TransactionCountMonitor {
     private previousCount: number | null = null;
     
     async monitorTransactionCount(
       config: { commitment?: string }
     ): Promise<TransactionCountChange | null> {
       const currentCount = await connection.getTransactionCount(config);
       
       if (this.previousCount !== null && this.previousCount !== currentCount) {
         const difference = currentCount - this.previousCount;
         const percentageChange = (difference / this.previousCount) * 100;
         
         this.previousCount = currentCount;
         
         return {
           changes: {
             previousCount: this.previousCount,
             currentCount,
             difference,
             percentageChange
           },
           metadata: {
             timestamp: Date.now()
           }
         };
       }
       
       this.previousCount = currentCount;
       return null;
     }
   }
   

3. Transaction Count Planning
   Copy

   interface TransactionCountPlan {
     currentCount: number;
     recommendations: Array<{
       type: 'scale' | 'optimize' | 'monitor';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }
   
   class TransactionCountPlanner {
     private readonly maxTransactionsPerSecond = 1000;
     private readonly minTransactionsPerSecond = 100;
     
     async planTransactionCount(
       config: { commitment?: string }
     ): Promise<TransactionCountPlan> {
       const currentCount = await connection.getTransactionCount(config);
       
       const recommendations: Array<{
         type: 'scale' | 'optimize' | 'monitor';
         reason: string;
       }> = [];
       
       // Check for high transaction rate
       if (currentCount > this.maxTransactionsPerSecond) {
         recommendations.push({
           type: 'scale',
           reason: `Transaction count (${currentCount}) exceeds maximum (${this.maxTransactionsPerSecond})`
         });
       }
       
       // Check for low transaction rate
       if (currentCount < this.minTransactionsPerSecond) {
         recommendations.push({
           type: 'optimize',
           reason: `Transaction count (${currentCount}) below minimum (${this.minTransactionsPerSecond})`
         });
       }
       
       return {
         currentCount,
         recommendations,
         metadata: {
           timestamp: Date.now()
         }
       };
     }
   }