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

# getSlotLeader

> Возвращает текущего лидера слота

## Параметры

<ResponseField name="config" type="object" optional>
  <Expandable title="поля config">
    <ResponseField name="commitment" type="string" optional>
      Уровень commitment (processed, confirmed, finalized)
    </ResponseField>
  </Expandable>
</ResponseField>

## Ответ

<ResponseField name="result" type="string">
  Публичный ключ текущего лидера слота (закодирован в base-58)
</ResponseField>

## Примеры кода

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

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

### Запрос с commitment

```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": "getSlotLeader",
  "params": [
    {
      "commitment": "confirmed"
    }
  ]
}'
```

### Использование 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 current slot leader
const slotLeader = await connection.getSlotLeader();
console.log('Current slot leader:', slotLeader);

// Get slot leader with commitment
async function getSlotLeaderWithCommitment(
  commitment: 'processed' | 'confirmed' | 'finalized' = 'confirmed'
) {
  const slotLeader = await connection.getSlotLeader(commitment);
  return {
    slotLeader,
    commitment,
    timestamp: Date.now()
  };
}
```

## Примечания

1. Возвращает публичный ключ текущего лидера слота
2. Лидер слота отвечает за производство следующего блока
3. Можно указывать различные уровни commitment
4. Ответ приходит немедленно, поскольку считывается из текущего состояния
5. Лидер слота меняется в соответствии с расписанием лидеров сети

## Лучшие практики

1. Кэшируйте лидера слота при необходимости
2. Рассмотрите использование подписки через websocket для обновлений в реальном времени
3. Обрабатывайте сетевые ошибки и повторяйте попытки при необходимости
4. Используйте подходящий уровень commitment в зависимости от ваших потребностей
5. Следите за сменами лидеров слота для анализа сети

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

| Код    | Сообщение                           | Решение                                                   |
| ------ | ----------------------------------- | --------------------------------------------------------- |
| -32601 | Method not found                    | Убедитесь, что вы подключены к узлу Solana RPC            |
| -32602 | Invalid params                      | Проверьте параметры config                                |
| -32007 | Slot leader information unavailable | Узел может выполнять начальную загрузку или синхронизацию |

## Примеры использования

1. **Мониторинг лидера слота**
   ```typescript theme={null}
   interface SlotLeaderInfo {
     slotLeader: string;
     commitment: string;
     metadata: {
       timestamp: number;
       previousLeader: string | null;
       leaderChanged: boolean;
     };
   }

   class SlotLeaderMonitor {
     private previousLeader: string | null = null;
     
     async monitorSlotLeader(
       commitment: 'processed' | 'confirmed' | 'finalized' = 'confirmed',
       interval: number = 1000
     ): Promise<SlotLeaderInfo> {
       const slotLeader = await connection.getSlotLeader(commitment);
       const timestamp = Date.now();
       
       const info: SlotLeaderInfo = {
         slotLeader,
         commitment,
         metadata: {
           timestamp,
           previousLeader: this.previousLeader,
           leaderChanged: this.previousLeader !== null && this.previousLeader !== slotLeader
         }
       };
       
       this.previousLeader = slotLeader;
       return info;
     }
   }
   ```

2. **Анализ лидеров слота**
   ```typescript theme={null}
   interface SlotLeaderAnalysis {
     currentLeader: string;
     leaderChanges: Array<{
       from: string;
       to: string;
       timestamp: number;
     }>;
     leaderDistribution: Record<string, number>;
     metadata: {
       startTime: number;
       duration: number;
     };
   }

   async function analyzeSlotLeaders(
     commitment: 'processed' | 'confirmed' | 'finalized' = 'confirmed',
     duration: number = 60000
   ): Promise<SlotLeaderAnalysis> {
     const startTime = Date.now();
     const leaderDistribution: Record<string, number> = {};
     const leaderChanges: Array<{
       from: string;
       to: string;
       timestamp: number;
     }> = [];
     let previousLeader = await connection.getSlotLeader(commitment);
     leaderDistribution[previousLeader] = 1;
     
     while (Date.now() - startTime < duration) {
       const currentLeader = await connection.getSlotLeader(commitment);
       
       if (currentLeader !== previousLeader) {
         leaderChanges.push({
           from: previousLeader,
           to: currentLeader,
           timestamp: Date.now()
         });
         previousLeader = currentLeader;
       }
       
       leaderDistribution[currentLeader] = (leaderDistribution[currentLeader] || 0) + 1;
       await new Promise(resolve => setTimeout(resolve, 1000));
     }
     
     return {
       currentLeader: previousLeader,
       leaderChanges,
       leaderDistribution,
       metadata: {
         startTime,
         duration: Date.now() - startTime
       }
     };
   }
   ```

3. **Отслеживание лидера слота**
   ```typescript theme={null}
   interface SlotLeaderTrack {
     leader: string;
     slot: number;
     metadata: {
       timestamp: number;
       commitment: string;
     };
   }

   class SlotLeaderTracker {
     async trackSlotLeader(
       commitment: 'processed' | 'confirmed' | 'finalized' = 'confirmed'
     ): Promise<SlotLeaderTrack> {
       const [leader, slot] = await Promise.all([
         connection.getSlotLeader(commitment),
         connection.getSlot()
       ]);
       
       return {
         leader,
         slot,
         metadata: {
           timestamp: Date.now(),
           commitment
         }
       };
     }
   }
   ```