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

# getInflationGovernor

> Returns the current inflation governor parameters

## Parameters

This method does not take any parameters.

## Response

<ResponseField name="result" type="object">
  <Expandable title="result fields">
    <ResponseField name="initial" type="number">
      Initial inflation percentage from time 0
    </ResponseField>

    <ResponseField name="terminal" type="number">
      Terminal inflation percentage
    </ResponseField>

    <ResponseField name="taper" type="number">
      Rate per year at which inflation is lowered
    </ResponseField>

    <ResponseField name="foundation" type="number">
      Percentage of total inflation allocated to the foundation
    </ResponseField>

    <ResponseField name="foundationTerm" type="number">
      Duration of foundation pool inflation in years
    </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": "getInflationGovernor"
}'
```

### 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 inflation governor parameters
const inflationGovernor = await connection.getInflationGovernor();
console.log('Initial inflation:', inflationGovernor.initial);
console.log('Terminal inflation:', inflationGovernor.terminal);
console.log('Taper rate:', inflationGovernor.taper);
console.log('Foundation percentage:', inflationGovernor.foundation);
console.log('Foundation term:', inflationGovernor.foundationTerm);

// Calculate current inflation rate
async function calculateCurrentInflation() {
  const inflationGovernor = await connection.getInflationGovernor();
  const epochInfo = await connection.getEpochInfo();
  
  const yearsSinceGenesis = epochInfo.absoluteSlot / (432000 * 365); // Approximate years
  const currentInflation = Math.max(
    inflationGovernor.terminal,
    inflationGovernor.initial - (inflationGovernor.taper * yearsSinceGenesis)
  );
  
  return {
    currentInflation,
    yearsSinceGenesis,
    initialInflation: inflationGovernor.initial,
    terminalInflation: inflationGovernor.terminal,
    taperRate: inflationGovernor.taper
  };
}
```

## Notes

1. Returns the parameters that govern inflation on the Solana network
2. Inflation decreases over time according to the taper rate
3. Foundation inflation is separate from validator inflation
4. The response is immediate as it reads from the current state
5. These parameters are set by governance and can change

## Best Practices

1. Use this method to understand the network's inflation schedule
2. Cache results when appropriate to reduce RPC load
3. Consider the impact of inflation on staking rewards
4. Monitor for changes in inflation parameters
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 Analysis**
   ```typescript theme={null}
   interface InflationMetrics {
     currentInflation: number;
     yearsSinceGenesis: number;
     initialInflation: number;
     terminalInflation: number;
     taperRate: number;
     foundationPercentage: number;
     foundationTerm: number;
     validatorInflation: number;
     foundationInflation: number;
   }

   async function analyzeInflation(): Promise<InflationMetrics> {
     const inflationGovernor = await connection.getInflationGovernor();
     const epochInfo = await connection.getEpochInfo();
     
     const yearsSinceGenesis = epochInfo.absoluteSlot / (432000 * 365);
     const currentInflation = Math.max(
       inflationGovernor.terminal,
       inflationGovernor.initial - (inflationGovernor.taper * yearsSinceGenesis)
     );
     
     const foundationInflation = yearsSinceGenesis < inflationGovernor.foundationTerm
       ? currentInflation * inflationGovernor.foundation
       : 0;
     
     return {
       currentInflation,
       yearsSinceGenesis,
       initialInflation: inflationGovernor.initial,
       terminalInflation: inflationGovernor.terminal,
       taperRate: inflationGovernor.taper,
       foundationPercentage: inflationGovernor.foundation,
       foundationTerm: inflationGovernor.foundationTerm,
       validatorInflation: currentInflation - foundationInflation,
       foundationInflation
     };
   }
   ```

2. **Staking Reward Projection**
   ```typescript theme={null}
   interface StakingProjection {
     currentAPY: number;
     futureAPY: number[];
     years: number[];
   }

   async function projectStakingRewards(
     totalStaked: number,
     totalSupply: number,
     years: number = 10
   ): Promise<StakingProjection> {
     const inflationGovernor = await connection.getInflationGovernor();
     const epochInfo = await connection.getEpochInfo();
     
     const currentYear = epochInfo.absoluteSlot / (432000 * 365);
     const yearsArray = Array.from({ length: years }, (_, i) => i);
     
     const futureAPY = yearsArray.map(year => {
       const inflation = Math.max(
         inflationGovernor.terminal,
         inflationGovernor.initial - (inflationGovernor.taper * (currentYear + year))
       );
       
       const foundationInflation = (currentYear + year) < inflationGovernor.foundationTerm
         ? inflation * inflationGovernor.foundation
         : 0;
       
       const validatorInflation = inflation - foundationInflation;
       return (validatorInflation * totalSupply) / totalStaked;
     });
     
     return {
       currentAPY: futureAPY[0],
       futureAPY,
       years: yearsArray
     };
   }
   ```

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

   async function monitorInflation(
     threshold: number = 0.01
   ): Promise<InflationAlert[]> {
     const inflationGovernor = await connection.getInflationGovernor();
     const epochInfo = await connection.getEpochInfo();
     
     const yearsSinceGenesis = epochInfo.absoluteSlot / (432000 * 365);
     const expectedInflation = Math.max(
       inflationGovernor.terminal,
       inflationGovernor.initial - (inflationGovernor.taper * yearsSinceGenesis)
     );
     
     const currentInflation = await connection.getInflationRate();
     const difference = Math.abs(currentInflation - expectedInflation);
     
     const alerts: InflationAlert[] = [];
     
     if (difference > threshold) {
       alerts.push({
         type: 'change',
         message: `Inflation differs from expected by ${difference.toFixed(4)}`,
         currentInflation,
         expectedInflation,
         difference
       });
     }
     
     if (currentInflation > inflationGovernor.initial) {
       alerts.push({
         type: 'high',
         message: `Inflation is above initial rate`,
         currentInflation,
         expectedInflation,
         difference
       });
     }
     
     if (currentInflation < inflationGovernor.terminal) {
       alerts.push({
         type: 'low',
         message: `Inflation is below terminal rate`,
         currentInflation,
         expectedInflation,
         difference
       });
     }
     
     return alerts;
   }
   ```