> ## 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.

# getInflationRate

> Returns the current inflation rate of the network

## Parameters

This method does not take any parameters.

## Response

<ResponseField name="result" type="object">
  <Expandable title="result fields">
    <ResponseField name="total" type="number">
      Total inflation rate as a percentage
    </ResponseField>

    <ResponseField name="validator" type="number">
      Inflation rate allocated to validators as a percentage
    </ResponseField>

    <ResponseField name="foundation" type="number">
      Inflation rate allocated to the foundation as a percentage
    </ResponseField>

    <ResponseField name="epoch" type="number">
      Current epoch number
    </ResponseField>
  </Expandable>
</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": "getInflationRate"
}'
```

### 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');

// Get current inflation rate
const inflationRate = await connection.getInflationRate();
console.log('Total inflation:', inflationRate.total);
console.log('Validator inflation:', inflationRate.validator);
console.log('Foundation inflation:', inflationRate.foundation);
console.log('Current epoch:', inflationRate.epoch);

// Calculate staking APY
async function calculateStakingAPY(totalStaked: number, totalSupply: number) {
  const inflationRate = await connection.getInflationRate();
  const validatorAPY = (inflationRate.validator * totalSupply) / totalStaked;
  
  return {
    validatorAPY,
    totalInflation: inflationRate.total,
    validatorInflation: inflationRate.validator,
    foundationInflation: inflationRate.foundation,
    epoch: inflationRate.epoch
  };
}
```

## Notes

1. Returns the current inflation rate and its allocation
2. Total inflation is split between validators and foundation
3. Inflation rates are expressed as percentages
4. The response is immediate as it reads from the current state
5. Inflation rates can change between epochs

## Best Practices

1. Use this method to understand current network inflation
2. Cache results when appropriate to reduce RPC load
3. Consider the impact of inflation on staking rewards
4. Monitor for changes in inflation rates
5. Use in conjunction with other inflation-related methods

## Common Errors

| Code   | Message                           | Solution                                     |
| ------ | --------------------------------- | -------------------------------------------- |
| -32601 | Method not found                  | Verify you're connected to a Solana RPC node |
| -32007 | Inflation information unavailable | Node may be bootstrapping or syncing         |

## Use Cases

1. **Inflation Tracking**
   ```typescript theme={null}
   interface InflationHistory {
     epoch: number;
     total: number;
     validator: number;
     foundation: number;
     timestamp: number;
   }

   async function trackInflationHistory(
     epochs: number = 10
   ): Promise<InflationHistory[]> {
     const history: InflationHistory[] = [];
     const currentEpoch = (await connection.getEpochInfo()).epoch;
     
     for (let i = 0; i < epochs; i++) {
       const epoch = currentEpoch - i;
       const inflationRate = await connection.getInflationRate();
       
       history.push({
         epoch: inflationRate.epoch,
         total: inflationRate.total,
         validator: inflationRate.validator,
         foundation: inflationRate.foundation,
         timestamp: Date.now()
       });
       
       // Add delay to avoid rate limiting
       await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
     return history;
   }
   ```

2. **Staking Analysis**
   ```typescript theme={null}
   interface StakingMetrics {
     currentAPY: number;
     projectedAPY: number;
     totalStaked: number;
     totalSupply: number;
     inflationRate: number;
     validatorInflation: number;
   }

   async function analyzeStakingMetrics(): Promise<StakingMetrics> {
     const inflationRate = await connection.getInflationRate();
     const supply = await connection.getSupply();
     const voteAccounts = await connection.getVoteAccounts();
     
     const totalStaked = voteAccounts.current
       .concat(voteAccounts.delinquent)
       .reduce((sum, account) => sum + account.activatedStake, 0);
     
     const currentAPY = (inflationRate.validator * supply.value.total) / totalStaked;
     
     // Project future APY based on current trends
     const projectedAPY = currentAPY * 0.95; // Assuming 5% decrease
     
     return {
       currentAPY,
       projectedAPY,
       totalStaked,
       totalSupply: supply.value.total,
       inflationRate: inflationRate.total,
       validatorInflation: inflationRate.validator
     };
   }
   ```

3. **Inflation Alerts**
   ```typescript theme={null}
   interface InflationAlert {
     type: 'high' | 'low' | 'change';
     message: string;
     currentRate: number;
     previousRate: number;
     difference: number;
   }

   class InflationMonitor {
     private previousRate: number | null = null;
     private threshold: number;
     
     constructor(threshold: number = 0.01) {
       this.threshold = threshold;
     }
     
     async checkInflation(): Promise<InflationAlert[]> {
       const inflationRate = await connection.getInflationRate();
       const alerts: InflationAlert[] = [];
       
       if (this.previousRate !== null) {
         const difference = Math.abs(inflationRate.total - this.previousRate);
         
         if (difference > this.threshold) {
           alerts.push({
             type: 'change',
             message: `Inflation rate changed by ${difference.toFixed(4)}`,
             currentRate: inflationRate.total,
             previousRate: this.previousRate,
             difference
           });
         }
       }
       
       // Check for unusually high or low rates
       if (inflationRate.total > 0.08) { // 8% threshold
         alerts.push({
           type: 'high',
           message: `Inflation rate is unusually high: ${inflationRate.total}`,
           currentRate: inflationRate.total,
           previousRate: this.previousRate || inflationRate.total,
           difference: 0
         });
       }
       
       if (inflationRate.total < 0.01) { // 1% threshold
         alerts.push({
           type: 'low',
           message: `Inflation rate is unusually low: ${inflationRate.total}`,
           currentRate: inflationRate.total,
           previousRate: this.previousRate || inflationRate.total,
           difference: 0
         });
       }
       
       this.previousRate = inflationRate.total;
       return alerts;
     }
   }
   ```