requestAirdrop

​

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": "requestAirdrop",
  "params": [
    "83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri",
    1000000000
  ]
}'

​

Using web3.js

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

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

// Request airdrop
const signature = await connection.requestAirdrop(
  new PublicKey('83astBRguLMdt2h5U1Tpdq5tjFoJ6noeGwaY3mDLVcri'),
  1000000000 // 1 SOL
);
console.log('Airdrop signature:', signature);

// Request airdrop with confirmation
async function requestAirdropWithConfirmation(
  pubkey: string,
  lamports: number,
  config: { commitment?: string }
) {
  const signature = await connection.requestAirdrop(
    new PublicKey(pubkey),
    lamports,
    config
  );
  
  // Wait for confirmation
  const confirmation = await connection.confirmTransaction(signature);
  
  return {
    signature,
    confirmation: {
      status: confirmation.value.err ? 'failed' : 'success',
      slot: confirmation.context.slot
    },
    request: {
      pubkey,
      lamports,
      formatted: lamports / 1e9 + ' SOL'
    },
    metadata: {
      timestamp: Date.now(),
      commitment: config.commitment
    }
  };
}

​

Notes

1. Requests an airdrop of SOL to a Solana account
2. Only available on test networks (devnet, testnet)
3. The response is the transaction signature
4. The transaction must be confirmed before funds are available
5. The amount is limited based on network configuration

​

Best Practices

1. Use appropriate commitment level based on your needs
2. Wait for transaction confirmation before proceeding
3. Handle rate limits and network errors
4. Consider using faucet services for larger amounts
5. Monitor transaction status for failures

​

Common Errors

​

Use Cases

1. Airdrop Management
   Copy

   interface AirdropRequest {
     request: {
       pubkey: string;
       lamports: number;
       formatted: string;
     };
     transaction: {
       signature: string;
       status: 'pending' | 'success' | 'failed';
       confirmations: number;
     };
     metadata: {
       timestamp: number;
       network: string;
       commitment?: string;
     };
   }
   
   class AirdropManager {
     private readonly maxRetries = 3;
     private readonly confirmationTimeout = 30000; // 30 seconds
     
     async requestAirdrop(
       pubkey: string,
       lamports: number,
       config: { commitment?: string }
     ): Promise<AirdropRequest> {
       let retries = 0;
       let signature: string;
       
       while (retries < this.maxRetries) {
         try {
           signature = await connection.requestAirdrop(
             new PublicKey(pubkey),
             lamports,
             config
           );
           
           // Wait for confirmation
           const confirmation = await connection.confirmTransaction(signature, config.commitment);
           
           if (!confirmation.value.err) {
             return {
               request: {
                 pubkey,
                 lamports,
                 formatted: lamports / 1e9 + ' SOL'
               },
               transaction: {
                 signature,
                 status: 'success',
                 confirmations: 1
               },
               metadata: {
                 timestamp: Date.now(),
                 network: connection.rpcEndpoint,
                 commitment: config.commitment
               }
             };
           }
         } catch (error) {
           retries++;
           if (retries === this.maxRetries) {
             throw error;
           }
           await new Promise(resolve => setTimeout(resolve, 1000));
         }
       }
     }
   }
   

2. Airdrop Monitoring
   Copy

   interface AirdropStatus {
     request: {
       pubkey: string;
       lamports: number;
     };
     status: {
       signature: string;
       confirmations: number;
       slot: number;
     };
     history: Array<{
       timestamp: number;
       status: string;
       confirmations: number;
     }>;
   }
   
   class AirdropMonitor {
     private requests: Map<string, AirdropStatus> = new Map();
     
     async monitorAirdrop(
       signature: string,
       request: {
         pubkey: string;
         lamports: number;
       }
     ): Promise<AirdropStatus> {
       let status = this.requests.get(signature);
       const now = Date.now();
       
       const confirmation = await connection.getSignatureStatus(signature);
       
       if (!status) {
         status = {
           request,
           status: {
             signature,
             confirmations: confirmation?.confirmations || 0,
             slot: confirmation?.slot || 0
           },
           history: [{
             timestamp: now,
             status: confirmation ? 'confirmed' : 'pending',
             confirmations: confirmation?.confirmations || 0
           }]
         };
       } else {
         status.status.confirmations = confirmation?.confirmations || 0;
         status.status.slot = confirmation?.slot || 0;
         status.history.push({
           timestamp: now,
           status: confirmation ? 'confirmed' : 'pending',
           confirmations: confirmation?.confirmations || 0
         });
       }
       
       this.requests.set(signature, status);
       return status;
     }
   }
   

3. Airdrop Planning
   Copy

   interface AirdropPlan {
     request: {
       pubkey: string;
       lamports: number;
       formatted: string;
     };
     recommendations: Array<{
       type: 'proceed' | 'split' | 'abort';
       reason: string;
     }>;
     metadata: {
       timestamp: number;
     };
   }
   
   class AirdropPlanner {
     private readonly maxAirdrop = 2000000000; // 2 SOL
     private readonly minAirdrop = 100000; // 0.0001 SOL
     
     async planAirdrop(
       pubkey: string,
       lamports: number
     ): Promise<AirdropPlan> {
       const recommendations: Array<{
         type: 'proceed' | 'split' | 'abort';
         reason: string;
       }> = [];
       
       if (lamports > this.maxAirdrop) {
         recommendations.push({
           type: 'split',
           reason: `Amount ${lamports} exceeds maximum airdrop of ${this.maxAirdrop}`
         });
       } else if (lamports < this.minAirdrop) {
         recommendations.push({
           type: 'abort',
           reason: `Amount ${lamports} is below minimum airdrop of ${this.minAirdrop}`
         });
       } else {
         recommendations.push({
           type: 'proceed',
           reason: 'Amount is within valid range'
         });
       }
       
       return {
         request: {
           pubkey,
           lamports,
           formatted: lamports / 1e9 + ' SOL'
         },
         recommendations,
         metadata: {
           timestamp: Date.now()
         }
       };
     }
     
     async splitAirdrop(
       pubkey: string,
       totalLamports: number
     ): Promise<Array<{
       lamports: number;
       delay: number;
     }>> {
       const chunks: Array<{
         lamports: number;
         delay: number;
       }> = [];
       
       let remaining = totalLamports;
       let delay = 0;
       
       while (remaining > 0) {
         const chunk = Math.min(remaining, this.maxAirdrop);
         chunks.push({
           lamports: chunk,
           delay
         });
         
         remaining -= chunk;
         delay += 2000; // 2 seconds between requests
       }
       
       return chunks;
     }
   }