requestAirdrop

​

Параметры

​

Ответ

​

Примеры кода

​

Базовый запрос

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

​

Использование web3.js

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

const connection = new Connection('https://fra.rpc.orbitflare.com?api_key=YOUR-API-KEY');

// 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
    }
  };
}

​

Примечания

1. Запрашивает аирдроп SOL на счёт Solana
2. Доступно только в тестовых сетях (devnet, testnet)
3. Ответ — это подпись транзакции
4. Транзакция должна быть подтверждена, прежде чем средства станут доступны
5. Сумма ограничена в зависимости от конфигурации сети

​

Рекомендации

1. Используйте подходящий уровень подтверждения в зависимости от ваших потребностей
2. Дождитесь подтверждения транзакции перед продолжением работы
3. Обрабатывайте ограничения запросов и сетевые ошибки
4. Рассмотрите использование faucet-сервисов для больших сумм
5. Отслеживайте статус транзакции на предмет сбоев

​

Распространённые ошибки

​

Сценарии использования

1. Управление аирдропом
   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. Мониторинг аирдропа
   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. Планирование аирдропа
   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()
         }
       };
     }
   }