> ## Documentation Index
> Fetch the complete documentation index at: https://docs.orbitflare.com/llms.txt
> Use this file to discover all available pages before exploring further.

# isBlockhashValid

> Returns whether a blockhash is still valid or not

## Parameters

<ResponseField name="blockhash" type="string" required>
  The blockhash to validate (base-58 encoded)
</ResponseField>

<ResponseField name="config" type="object" optional>
  Configuration object containing:

  <ResponseField name="commitment" type="string" optional>
    Commitment level (processed, confirmed, finalized)
  </ResponseField>

  <ResponseField name="minContextSlot" type="number" optional>
    The minimum slot that the request can be evaluated at
  </ResponseField>
</ResponseField>

## Response

<ResponseField name="result" type="boolean">
  Whether the blockhash is still valid (true) or not (false)
</ResponseField>

## Code Examples

### Basic Request

```bash theme={null}
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

```typescript theme={null}
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

| Code   | Message             | Solution                                     |
| ------ | ------------------- | -------------------------------------------- |
| -32601 | Method not found    | Verify you're connected to a Solana RPC node |
| -32602 | Invalid params      | Check the blockhash format                   |
| -32007 | Blockhash not found | The blockhash has expired or is invalid      |

## Use Cases

1. **Blockhash Validation**
   ```typescript theme={null}
   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**
   ```typescript theme={null}
   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**
   ```typescript theme={null}
   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;
     }
   }
   ```