isBlockhashValid

​

Parameters

​

Response

​

Code Examples

​

Basic Request

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": "isBlockhashValid",
  "params": [
    "J7rBdM6AecPDEZp8aPq5tPmsPzPhQG4HD6YtAcQBDfJj"
  ]
}'

​

Using web3.js

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

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

// Check if blockhash is valid
const isValid = await connection.isBlockhashValid('J7rBdM6AecPDEZp8aPq5tPmsPzPhQG4HD6YtAcQBDfJj');
console.log('Is blockhash valid:', isValid);

// Check blockhash validity with analysis
async function checkBlockhashValidityWithAnalysis(
  blockhash: string,
  config: { 
    commitment?: string;
    minContextSlot?: number;
  }
) {
  const isValid = await connection.isBlockhashValid(blockhash, config);
  
  return {
    blockhash,
    validity: {
      isValid,
      checkedAt: Date.now()
    },
    config: {
      commitment: config.commitment,
      minContextSlot: config.minContextSlot
    }
  };
}

​

Notes

1. Returns whether a blockhash is still valid
2. Blockhashes expire after a certain number of slots
3. The response is immediate as it reads from the current state
4. Invalid blockhashes cannot be used in transactions
5. The blockhash must be base-58 encoded

​

Best Practices

1. Use appropriate commitment level based on your needs
2. Cache results when appropriate to reduce RPC load
3. Check blockhash validity before sending transactions
4. Consider using websocket subscription for real-time updates
5. Handle network errors and retry when appropriate

​

Common Errors

​

Use Cases

1. Blockhash Validation
   interface BlockhashValidation {
     blockhash: string;
     validity: {
       isValid: boolean;
       checkedAt: number;
     };
     config: {
       commitment?: string;
       minContextSlot?: number;
     };
   }
   
   class BlockhashValidator {
     async validateBlockhash(
       blockhash: string,
       config: { 
         commitment?: string;
         minContextSlot?: number;
       }
     ): Promise<BlockhashValidation> {
       const isValid = await connection.isBlockhashValid(blockhash, config);
       
       return {
         blockhash,
         validity: {
           isValid,
           checkedAt: Date.now()
         },
         config: {
           commitment: config.commitment,
           minContextSlot: config.minContextSlot
         }
       };
     }
   }
   
2. Blockhash Monitoring
   interface BlockhashStatus {
     blockhash: string;
     status: {
       isValid: boolean;
       lastChecked: number;
       checkCount: number;
     };
     history: Array<{
       timestamp: number;
       isValid: boolean;
     }>;
   }
   
   class BlockhashMonitor {
     private statuses: Map<string, BlockhashStatus> = new Map();
     
     async monitorBlockhash(
       blockhash: string,
       config: { 
         commitment?: string;
         minContextSlot?: number;
       }
     ): Promise<BlockhashStatus> {
       const isValid = await connection.isBlockhashValid(blockhash, config);
       const now = Date.now();
       
       let status = this.statuses.get(blockhash);
       if (!status) {
         status = {
           blockhash,
           status: {
             isValid,
             lastChecked: now,
             checkCount: 1
           },
           history: [{
             timestamp: now,
             isValid
           }]
         };
       } else {
         status.status.isValid = isValid;
         status.status.lastChecked = now;
         status.status.checkCount++;
         status.history.push({
           timestamp: now,
           isValid
         });
       }
       
       this.statuses.set(blockhash, status);
       return status;
     }
   }
   
3. Transaction Planning
   interface TransactionPlan {
     blockhash: string;
     validity: {
       isValid: boolean;
       checkedAt: number;
     };
     recommendations: Array<{
       type: 'proceed' | 'retry' | 'abort';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }
   
   class TransactionPlanner {
     private readonly maxRetries = 3;
     private readonly validityCheckInterval = 1000; // 1 second
     
     async planTransaction(
       blockhash: string,
       config: { 
         commitment?: string;
         minContextSlot?: number;
       }
     ): Promise<TransactionPlan> {
       const isValid = await connection.isBlockhashValid(blockhash, config);
       const now = Date.now();
       
       const recommendations: Array<{
         type: 'proceed' | 'retry' | 'abort';
         reason: string;
       }> = [];
       
       if (isValid) {
         recommendations.push({
           type: 'proceed',
           reason: 'Blockhash is valid'
         });
       } else {
         recommendations.push({
           type: 'abort',
           reason: 'Blockhash is invalid'
         });
         
         recommendations.push({
           type: 'retry',
           reason: 'Get a new blockhash and retry'
         });
       }
       
       return {
         blockhash,
         validity: {
           isValid,
           checkedAt: now
         },
         recommendations,
         metadata: {
           timestamp: now
         }
       };
     }
     
     async waitForValidBlockhash(
       blockhash: string,
       config: { 
         commitment?: string;
         minContextSlot?: number;
       }
     ): Promise<boolean> {
       let retries = 0;
       
       while (retries < this.maxRetries) {
         const isValid = await connection.isBlockhashValid(blockhash, config);
         
         if (isValid) {
           return true;
         }
         
         retries++;
         await new Promise(resolve => setTimeout(resolve, this.validityCheckInterval));
       }
       
       return false;
     }
   }