getSupply

​

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

​

Using web3.js

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

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

// Get supply
const supply = await connection.getSupply();
console.log('Supply:', supply);

// Get supply with analysis
async function getSupplyWithAnalysis(
  config?: { commitment?: string; excludeNonCirculatingAccountsList?: boolean }
) {
  const supply = await connection.getSupply(config);
  
  return {
    supply,
    analysis: {
      totalInSOL: supply.total / 1e9,
      circulatingInSOL: supply.circulating / 1e9,
      nonCirculatingInSOL: supply.nonCirculating / 1e9,
      circulatingPercentage: (supply.circulating / supply.total) * 100,
      metadata: {
        timestamp: Date.now(),
        commitment: config?.commitment
      }
    }
  };
}

​

Notes

1. Returns the current supply of SOL in lamports
2. The supply is broken down into total, circulating, and non-circulating amounts
3. The response is immediate as it reads from the current state
4. The supply can change with network activity and inflation
5. Non-circulating accounts are typically controlled by the Solana Foundation

​

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 the supply
4. Consider using websocket subscription for real-time updates
5. Handle network errors and retry when appropriate

​

Common Errors

​

Use Cases

1. Supply Analysis

   interface SupplyAnalysis {
     supply: {
       total: number;
       circulating: number;
       nonCirculating: number;
     };
     metrics: {
       totalInSOL: number;
       circulatingInSOL: number;
       nonCirculatingInSOL: number;
       circulatingPercentage: number;
       inflationRate?: number;
     };
     metadata: {
       timestamp: number;
       commitment?: string;
     };
   }
   
   class SupplyAnalyzer {
     private previousSupply: number | null = null;
     
     async analyzeSupply(
       config?: { commitment?: string; excludeNonCirculatingAccountsList?: boolean }
     ): Promise<SupplyAnalysis> {
       const supply = await connection.getSupply(config);
       const currentTimestamp = Date.now();
       
       const metrics = {
         totalInSOL: supply.total / 1e9,
         circulatingInSOL: supply.circulating / 1e9,
         nonCirculatingInSOL: supply.nonCirculating / 1e9,
         circulatingPercentage: (supply.circulating / supply.total) * 100
       };
       
       if (this.previousSupply !== null) {
         const timeElapsed = (currentTimestamp - this.previousSupply) / (1000 * 60 * 60 * 24); // Days
         const supplyChange = supply.total - this.previousSupply;
         metrics.inflationRate = (supplyChange / this.previousSupply) * (365 / timeElapsed) * 100;
       }
       
       this.previousSupply = supply.total;
       
       return {
         supply,
         metrics,
         metadata: {
           timestamp: currentTimestamp,
           commitment: config?.commitment
         }
       };
     }
   }
   

2. Supply Monitoring

   interface SupplyChange {
     previousSupply: {
       total: number;
       circulating: number;
       nonCirculating: number;
     };
     currentSupply: {
       total: number;
       circulating: number;
       nonCirculating: number;
     };
     changes: {
       total: number;
       circulating: number;
       nonCirculating: number;
     };
     metadata: {
       timestamp: number;
     };
   }
   
   class SupplyMonitor {
     private previousSupply: {
       total: number;
       circulating: number;
       nonCirculating: number;
     } | null = null;
     
     async monitorSupply(
       config?: { commitment?: string; excludeNonCirculatingAccountsList?: boolean }
     ): Promise<SupplyChange | null> {
       const currentSupply = await connection.getSupply(config);
       
       if (this.previousSupply === null) {
         this.previousSupply = currentSupply;
         return null;
       }
       
       const changes = {
         total: currentSupply.total - this.previousSupply.total,
         circulating: currentSupply.circulating - this.previousSupply.circulating,
         nonCirculating: currentSupply.nonCirculating - this.previousSupply.nonCirculating
       };
       
       if (changes.total !== 0 || changes.circulating !== 0 || changes.nonCirculating !== 0) {
         const change: SupplyChange = {
           previousSupply: this.previousSupply,
           currentSupply,
           changes,
           metadata: {
             timestamp: Date.now()
           }
         };
         
         this.previousSupply = currentSupply;
         return change;
       }
       
       return null;
     }
   }
   

3. Supply Planning

   interface SupplyProjection {
     currentSupply: {
       total: number;
       circulating: number;
       nonCirculating: number;
     };
     projections: Array<{
       days: number;
       total: number;
       circulating: number;
       nonCirculating: number;
     }>;
     metadata: {
       timestamp: number;
       inflationRate: number;
     };
   }
   
   class SupplyPlanner {
     private readonly defaultInflationRate = 0.08; // 8% annual inflation
     
     async projectSupply(
       config?: { commitment?: string; excludeNonCirculatingAccountsList?: boolean },
       days: number[] = [30, 90, 365]
     ): Promise<SupplyProjection> {
       const currentSupply = await connection.getSupply(config);
       const currentTimestamp = Date.now();
       
       const projections = days.map(daysAhead => {
         const years = daysAhead / 365;
         const total = currentSupply.total * Math.pow(1 + this.defaultInflationRate, years);
         const circulating = currentSupply.circulating * Math.pow(1 + this.defaultInflationRate, years);
         const nonCirculating = currentSupply.nonCirculating * Math.pow(1 + this.defaultInflationRate, years);
         
         return {
           days: daysAhead,
           total,
           circulating,
           nonCirculating
         };
       });
       
       return {
         currentSupply,
         projections,
         metadata: {
           timestamp: currentTimestamp,
           inflationRate: this.defaultInflationRate
         }
       };
     }
   }