Leader Rotation

LEADER SELECTION OVERVIEW
═════════════════════════

Inputs:
├── Stake distribution at epoch boundary
├── Randomness from bank hash
└── Slot number

Output:
├── Exactly one leader per slot
├── Leaders known ~2 days ahead
└── Proportional to stake

// Simplified leader selection algorithm
interface StakeDistribution {
  validator: PublicKey;
  stake: number;
}

function selectLeaderForSlot(
  stakes: StakeDistribution[],
  slot: number,
  epochRandomSeed: Buffer,
): PublicKey {
  // Calculate total stake
  const totalStake = stakes.reduce((sum, s) => sum + s.stake, 0);

  // Generate deterministic random number for this slot
  const slotSeed = sha256(
    Buffer.concat([epochRandomSeed, Buffer.from(slot.toString())]),
  );
  const randomValue = slotSeed.readBigUInt64LE(0);

  // Select leader based on stake weight
  const target = Number(randomValue % BigInt(totalStake));

  let cumulative = 0;
  for (const { validator, stake } of stakes) {
    cumulative += stake;
    if (target < cumulative) {
      return validator;
    }
  }

  // Should never reach here
  return stakes[stakes.length - 1].validator;
}

// Generate full epoch schedule
function generateLeaderSchedule(
  stakes: StakeDistribution[],
  epochRandomSeed: Buffer,
  slotsPerEpoch: number,
): Map<number, PublicKey> {
  const schedule = new Map<number, PublicKey>();

  for (let slot = 0; slot < slotsPerEpoch; slot++) {
    const leader = selectLeaderForSlot(stakes, slot, epochRandomSeed);
    schedule.set(slot, leader);
  }

  return schedule;
}

SLOT BLOCK ASSIGNMENT
═════════════════════

Instead of:
Slot 0: A, Slot 1: B, Slot 2: A, Slot 3: C, Slot 4: B...

Solana uses 4-slot blocks:
Slots 0-3: Validator A (4 consecutive slots)
Slots 4-7: Validator B (4 consecutive slots)
Slots 8-11: Validator C (4 consecutive slots)
Slots 12-15: Validator A (4 consecutive slots)
...

Benefits:
├── Reduces context switching
├── Leader can prepare transactions
├── Network can stabilize connections
└── More efficient state handling

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

const connection = new Connection("https://api.mainnet-beta.solana.com");

// Get current slot's leader
async function getCurrentLeader(): Promise<PublicKey> {
  return await connection.getSlotLeader();
}

// Get leaders for upcoming slots
async function getUpcomingLeaders(count: number): Promise<PublicKey[]> {
  const currentSlot = await connection.getSlot();
  return await connection.getSlotLeaders(currentSlot, count);
}

// Example: Monitor leader changes
async function monitorLeaders() {
  let lastLeader: string | null = null;

  setInterval(async () => {
    const slot = await connection.getSlot();
    const leader = await connection.getSlotLeader();
    const leaderStr = leader.toBase58();

    if (leaderStr !== lastLeader) {
      console.log(`Slot ${slot}: New leader ${leaderStr.slice(0, 8)}...`);
      lastLeader = leaderStr;
    }
  }, 400); // Check every slot
}

PROBABILITY CALCULATION
═══════════════════════

Validator stake: S
Total network stake: T
Slots per epoch: 432,000

Expected leader slots = (S / T) × 432,000

Examples:
─────────────────────────────────────────────
Stake    | % of Total | Expected Slots/Epoch
─────────────────────────────────────────────
100K SOL |    0.1%    |        432 slots
1M SOL   |    1.0%    |       4,320 slots
10M SOL  |   10.0%    |      43,200 slots
─────────────────────────────────────────────

Standard deviation ≈ √(expected × (1 - probability))

For 1% stake:
σ ≈ √(4,320 × 0.99) ≈ 65 slots

So actual might be 4,320 ± 130 slots (2σ range)

// Calculate expected leader slots
function calculateExpectedSlots(
  validatorStake: number,
  totalStake: number,
  slotsPerEpoch: number = 432000,
): {
  expected: number;
  standardDeviation: number;
  range95: [number, number];
} {
  const probability = validatorStake / totalStake;
  const expected = probability * slotsPerEpoch;

  // Binomial distribution standard deviation
  const variance = slotsPerEpoch * probability * (1 - probability);
  const standardDeviation = Math.sqrt(variance);

  // 95% confidence interval (±2σ)
  const range95: [number, number] = [
    Math.floor(expected - 2 * standardDeviation),
    Math.ceil(expected + 2 * standardDeviation),
  ];

  return { expected, standardDeviation, range95 };
}

// Example
const stats = calculateExpectedSlots(
  1_000_000, // 1M SOL stake
  100_000_000, // 100M total stake
);
console.log(stats);
// { expected: 4320, standardDeviation: 65.4, range95: [4189, 4451] }

LEADER PREPARATION TIMELINE
═══════════════════════════

Epoch N starts
│
├── Leader schedule for Epoch N is known
│   (calculated from Epoch N-1 stake snapshot)
│
├── Validator sees: "I lead slots 1000-1003"
│
│   Slot 996: Start preparing
│   ├── Pre-fetch hot accounts
│   ├── Build transaction pipeline
│   └── Connect to clients
│
│   Slot 1000: Begin producing
│   ├── Receive transactions via TPU
│   ├── Execute and order
│   └── Broadcast to validators
│
│   Slot 1003: Last leader slot
│
│   Slot 1004: New leader takes over
│
└── Prepare for next leader round

// Conceptual transaction flow
interface TransactionFlow {
  // User submits to any RPC
  submission: {
    from: "User";
    to: "RPC Node";
    data: "Signed Transaction";
  };

  // RPC determines leader
  routing: {
    from: "RPC Node";
    step: "Lookup current and next 2 leaders";
    result: ["Leader A", "Leader B", "Leader C"];
  };

  // Forward to leader(s)
  forwarding: {
    from: "RPC Node";
    to: "Current Leader + Next Leaders";
    reason: "Handles network delays and leader transitions";
  };

  // Leader processes
  processing: {
    at: "Leader";
    steps: [
      "Receive via TPU",
      "Verify signature",
      "Execute program",
      "Include in block",
    ];
  };
}

TIME ────────────────────────────────────────────────────────────────►

Slot:    0    1    2    3    4    5    6    7    8    9   10   11
       ┌────────────────┐┌────────────────┐┌────────────────┐
Leader: │   Validator A  ││   Validator B  ││   Validator C  │
       └────────────────┘└────────────────┘└────────────────┘

Transaction journey (submitted at slot 1):
───────────────────────────────────────────

User         RPC         Validator A      Network        Validators
  │           │               │              │               │
  │──Submit──►│               │              │               │
  │           │──Forward─────►│              │               │
  │           │               │──Process     │               │
  │           │               │──Create PoH  │               │
  │           │               │──Broadcast──►│──────────────►│
  │           │               │              │               │──Vote
  │           │◄──Confirm─────│◄─────────────│◄──────────────│
  │◄──Done────│               │              │               │
  │           │               │              │               │

Total time: ~400-800ms to confirmation

LEADER FAILURE SCENARIO
═══════════════════════

Slot 100: Leader A (online) → Produces block ✓
Slot 101: Leader A (online) → Produces block ✓
Slot 102: Leader A (OFFLINE) → Slot skipped ✗
Slot 103: Leader A (OFFLINE) → Slot skipped ✗
Slot 104: Leader B (online) → Produces block ✓

What happens to transactions during 102-103?
├── RPCs detect leader unresponsive
├── Transactions forwarded to Leader B
├── Leader B queues them for slot 104
└── Transactions complete in slot 104

Impact:
├── ~800ms delay (2 skipped slots)
├── Skip rate increases
├── Leader A's reputation decreases
└── Network continues without interruption

// How validators detect missed slots
interface SlotTimeout {
  // PoH provides timing
  expectedTicksPerSlot: 64;
  msPerTick: 6.25; // approximately

  // Grace period for network delays
  graceMs: 200; // Allow late blocks

  // Total timeout
  totalTimeoutMs: 600; // 400ms slot + 200ms grace

  // After timeout
  action: "Mark slot as skipped, continue to next slot";
}

// Skip rate calculation
function calculateSkipRate(producedBlocks: number, totalSlots: number): number {
  const skipped = totalSlots - producedBlocks;
  return skipped / totalSlots;
}

// Network health indicator
// Healthy: < 5% skip rate
// Warning: 5-10% skip rate
// Critical: > 10% skip rate

THE TRADEOFF
════════════

Benefits of predictable schedule:
├── Leaders can prepare
├── Transactions route efficiently
├── Network load balances
└── Lower latency

Risks of predictable schedule:
├── DDoS attacks on known leaders
├── Front-running opportunities
├── Targeted attacks before leader slot
└── MEV extraction planning

Mitigations:
├── Short leader slots (4 at a time)
├── Multiple validators processing
├── Jito-style MEV distribution
├── Rate limiting at validators
└── Geographic distribution

GRINDING ATTACK
═══════════════

Attack vector:
Manipulate the random seed to gain more leader slots

Prevention (simplified):
├── Random seed from PoH (cannot be influenced)
├── Stake snapshot from past epoch
├── Cannot change stake retroactively
└── Cost of manipulation > benefit

Math:
To gain 1 extra slot with 1% stake:
├── Would need to manipulate seed
├── Seed is hash of entire chain state
├── Computationally infeasible
└── Would need 51% stake anyway

// Best practices for transaction submission

import { Connection, Transaction, Keypair } from "@solana/web3.js";

async function sendTransactionOptimally(
  connection: Connection,
  transaction: Transaction,
  signer: Keypair,
): Promise<string> {
  // 1. Get fresh blockhash
  const { blockhash, lastValidBlockHeight } =
    await connection.getLatestBlockhash("confirmed");

  transaction.recentBlockhash = blockhash;
  transaction.feePayer = signer.publicKey;

  // 2. Sign transaction
  transaction.sign(signer);

  // 3. Send with skip preflight for speed
  const signature = await connection.sendRawTransaction(
    transaction.serialize(),
    {
      skipPreflight: true, // Faster, but less error info
      maxRetries: 3,
    },
  );

  // 4. Confirm with timeout
  try {
    await connection.confirmTransaction(
      {
        signature,
        blockhash,
        lastValidBlockHeight,
      },
      "confirmed",
    );
  } catch (error) {
    // Transaction may still succeed, check status
    const status = await connection.getSignatureStatus(signature);
    if (status.value?.err) {
      throw new Error(`Transaction failed: ${status.value.err}`);
    }
  }

  return signature;
}

# Monitor leader slots
solana leader-schedule | grep $(solana-keygen pubkey ~/validator-keypair.json)

# Check skip rate
solana validators --sort skip-rate

# View upcoming leader slots
solana slot-leaders --num 100

# Monitor your validator's performance
solana-watchtower

// Complete leader schedule interaction

// 1. Get full schedule for epoch
const leaderSchedule = await connection.getLeaderSchedule();

// leaderSchedule structure:
// {
//   "ValidatorPubkeyA": [0, 1, 2, 3, 100, 101, 102, 103, ...],
//   "ValidatorPubkeyB": [4, 5, 6, 7, ...],
//   ...
// }

// 2. Find when specific validator leads
function getLeaderSlotsForValidator(
  schedule: Record<string, number[]>,
  validatorKey: string,
): number[] {
  return schedule[validatorKey] || [];
}

// 3. Find leader for specific slot
function getLeaderForSlot(
  schedule: Record<string, number[]>,
  slotIndex: number,
): string | null {
  for (const [validator, slots] of Object.entries(schedule)) {
    if (slots.includes(slotIndex)) {
      return validator;
    }
  }
  return null;
}

// 4. Get next leader change
async function getNextLeaderChange(
  connection: Connection,
): Promise<{ slot: number; newLeader: PublicKey }> {
  const currentSlot = await connection.getSlot();
  const leaders = await connection.getSlotLeaders(currentSlot, 100);

  const currentLeader = leaders[0].toBase58();

  for (let i = 1; i < leaders.length; i++) {
    if (leaders[i].toBase58() !== currentLeader) {
      return {
        slot: currentSlot + i,
        newLeader: leaders[i],
      };
    }
  }

  return {
    slot: currentSlot + 100,
    newLeader: leaders[leaders.length - 1],
  };
}