getTokenSupply

​

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

​

Using web3.js

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

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

// Get token supply
const mint = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
const supply = await connection.getTokenSupply(mint);
console.log('Token supply:', supply);

// Get token supply with analysis
async function getTokenSupplyWithAnalysis(
  mint: PublicKey,
  config: { commitment?: string }
) {
  const supply = await connection.getTokenSupply(mint, config);
  
  return {
    supply,
    analysis: {
      rawAmount: BigInt(supply.value.amount),
      formattedAmount: supply.value.uiAmountString,
      decimals: supply.value.decimals,
      metadata: {
        timestamp: Date.now(),
        commitment: config.commitment
      }
    }
  };
}

​

Notes

1. Returns the total supply of a token mint
2. The supply includes all tokens in circulation
3. The response is immediate as it reads from the current state
4. The supply can change with token minting and burning
5. The mint must be a valid token mint

​

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

​

Common Errors

​

Use Cases

1. Token Supply Analysis

   interface TokenSupplyAnalysis {
     mint: string;
     supply: {
       rawAmount: string;
       formattedAmount: string;
       decimals: number;
     };
     metrics: {
       maxSupply?: string;
       burnedAmount?: string;
       circulatingSupply?: string;
       inflationRate?: number;
     };
     metadata: {
       timestamp: number;
       commitment?: string;
     };
   }
   
   class TokenSupplyAnalyzer {
     private readonly maxSupply: Record<string, bigint> = {
       'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v': BigInt(1000000000000000) // USDC
     };
     
     async analyzeTokenSupply(
       mint: PublicKey,
       config: { commitment?: string }
     ): Promise<TokenSupplyAnalysis> {
       const supply = await connection.getTokenSupply(mint, config);
       const rawAmount = BigInt(supply.value.amount);
       const maxSupply = this.maxSupply[mint.toBase58()];
       
       return {
         mint: mint.toBase58(),
         supply: {
           rawAmount: supply.value.amount,
           formattedAmount: supply.value.uiAmountString!,
           decimals: supply.value.decimals
         },
         metrics: {
           maxSupply: maxSupply?.toString(),
           burnedAmount: maxSupply ? (maxSupply - rawAmount).toString() : undefined,
           circulatingSupply: supply.value.uiAmountString,
           inflationRate: maxSupply ? Number((rawAmount * BigInt(100)) / maxSupply) : undefined
         },
         metadata: {
           timestamp: Date.now(),
           commitment: config.commitment
         }
       };
     }
   }
   

2. Token Supply Monitoring

   interface TokenSupplyChange {
     mint: string;
     changes: {
       previousAmount: string;
       currentAmount: string;
       difference: string;
       percentageChange: number;
     };
     metadata: {
       timestamp: number;
     };
   }
   
   class TokenSupplyMonitor {
     private previousSupply: Map<string, string> = new Map();
     
     async monitorTokenSupply(
       mint: PublicKey,
       config: { commitment?: string }
     ): Promise<TokenSupplyChange | null> {
       const supply = await connection.getTokenSupply(mint, config);
       const currentAmount = supply.value.amount;
       const previousAmount = this.previousSupply.get(mint.toBase58());
       
       if (previousAmount && previousAmount !== currentAmount) {
         const difference = BigInt(currentAmount) - BigInt(previousAmount);
         const percentageChange = Number((difference * BigInt(100)) / BigInt(previousAmount));
         
         this.previousSupply.set(mint.toBase58(), currentAmount);
         
         return {
           mint: mint.toBase58(),
           changes: {
             previousAmount,
             currentAmount,
             difference: difference.toString(),
             percentageChange
           },
           metadata: {
             timestamp: Date.now()
           }
         };
       }
       
       this.previousSupply.set(mint.toBase58(), currentAmount);
       return null;
     }
   }
   

3. Token Supply Planning

   interface TokenSupplyPlan {
     mint: string;
     currentSupply: {
       rawAmount: string;
       formattedAmount: string;
       decimals: number;
     };
     recommendations: Array<{
       type: 'mint' | 'burn' | 'freeze';
       amount?: string;
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }
   
   class TokenSupplyPlanner {
     private readonly targetInflationRate = 0.02; // 2% annual inflation
     private readonly maxSupply: Record<string, bigint> = {
       'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v': BigInt(1000000000000000) // USDC
     };
     
     async planTokenSupply(
       mint: PublicKey,
       config: { commitment?: string }
     ): Promise<TokenSupplyPlan> {
       const supply = await connection.getTokenSupply(mint, config);
       const rawAmount = BigInt(supply.value.amount);
       const maxSupply = this.maxSupply[mint.toBase58()];
       
       const recommendations: Array<{
         type: 'mint' | 'burn' | 'freeze';
         amount?: string;
         reason: string;
       }> = [];
       
       if (maxSupply) {
         const currentInflationRate = Number((rawAmount * BigInt(100)) / maxSupply) / 100;
         const targetAmount = maxSupply * BigInt(Math.floor(this.targetInflationRate * 100)) / BigInt(100);
         
         if (currentInflationRate > this.targetInflationRate) {
           const burnAmount = rawAmount - targetAmount;
           recommendations.push({
             type: 'burn',
             amount: burnAmount.toString(),
             reason: `Current inflation rate (${(currentInflationRate * 100).toFixed(2)}%) exceeds target (${(this.targetInflationRate * 100).toFixed(2)}%)`
           });
         } else if (currentInflationRate < this.targetInflationRate) {
           const mintAmount = targetAmount - rawAmount;
           recommendations.push({
             type: 'mint',
             amount: mintAmount.toString(),
             reason: `Current inflation rate (${(currentInflationRate * 100).toFixed(2)}%) below target (${(this.targetInflationRate * 100).toFixed(2)}%)`
           });
         }
       }
       
       return {
         mint: mint.toBase58(),
         currentSupply: {
           rawAmount: supply.value.amount,
           formattedAmount: supply.value.uiAmountString!,
           decimals: supply.value.decimals
         },
         recommendations,
         metadata: {
           timestamp: Date.now()
         }
       };
     }
   }