Epoch Processing

An epoch is a periodic recalculation that runs Yuma Consensus and distributes rewards. Epochs are part of block execution, triggered by each subnet's tempo parameter.

Step 1: Check Tempo Trigger

Each subnet has a Tempo parameter that determines how often its epoch runs. At each block, the runtime checks whether this subnet's epoch is due. Subnets are staggered by their network ID so they don't all run in the same block:

The netuid offset ensures subnets with the same tempo run in different blocks, spreading the computation load. The + 1 adjustments prevent division-by-zero edge cases.

Common tempo values:

Block time is ~12 seconds, so tempo 100 = ~20 minutes between epochs.

Step 2: Read Current State

When an epoch triggers, the runtime reads all relevant state from storage:

Step 3: Filter Active Participants

Before computing consensus, several filters are applied to determine which neurons participate:

// Simplified filtering logic
let active = last_update.map(|block|
    current_block - block < activity_cutoff
);

let filtered_stake = stake.map(|s|
    if s < min_stake { 0 } else { s }
);

// Mask non-validators and self-weights
weights = mask_rows(&validator_forbids, &weights);
weights = mask_diag(&weights);

Step 4: Run Yuma Consensus

With filtered inputs, the Yuma Consensus algorithm runs:

1. Compute consensus: Stake-weighted median per miner
2. Clip weights: Limit all weights to consensus values
3. Calculate ranks: Stake-weighted sum of clipped weights
4. Normalize to incentive: Miner emission shares
5. Update bonds: EMA of weight × stake products
6. Calculate dividends: Validator shares from bond positions

See Yuma Consensus for the detailed algorithm.

Step 5: Compute Emission Distribution

The epoch determines how the subnet's accumulated emission is distributed:

Emission accumulates in pending storage items and is released to wallets when the epoch completes. See Emission Mechanics for the full flow.

Step 6: Write Results to Storage

Finally, all computed values are written back to on-chain storage:

Yuma3 Variant

Yuma3 is an enhanced epoch algorithm enabled per-subnet via the Yuma3On flag.

Key Differences

Liquid Alpha

In Yuma3, the EMA alpha for bond updates is dynamic. Weights closer to consensus get faster bond accumulation:

// Liquid alpha: consensus-aligned weights bond faster
fn liquid_alpha(weight, consensus, bond, alpha_low, alpha_high) {
    let diff = if weight >= bond {
        weight - consensus  // buying position
    } else {
        bond - weight       // selling position
    };

    // Sigmoid: closer to 0 diff = higher alpha
    let sigmoid = 1 / (1 + exp(-steepness * (diff - 0.5)));
    alpha_low + sigmoid * (alpha_high - alpha_low)
}

The alpha range is configured by AlphaValues (which stores both the low and high bounds).

Performance Considerations

Epoch processing must complete within block time constraints (~12 seconds for all subnets combined). Optimizations include:

• Sparse matrices: Weights and bonds are stored as sparse vectors (Vec<(uid, u16)>) to handle subnets with many neurons
• Fixed-point arithmetic: All computations use I32F32 fixed-point to avoid floating-point non-determinism across nodes
• Efficient median: Pivot-based search instead of full sorting for the weighted median calculation

Epoch Events

The epoch emits events that can be observed on-chain:

• IncentiveAlphaEmittedToMiners: Server emission per miner

These events allow indexers and explorers to track emission distribution without parsing storage changes.

Related Pages

• Yuma Consensus: The core algorithm run during epochs
• Emission Mechanics: How emission flows to neurons
• Block Execution: Where epochs fit in the block lifecycle
• Glossary: Definitions for tempo, epoch, bonds, etc.

Source Code

Epoch processing is implemented in:

• pallets/subtensor/src/epoch/run_epoch.rs
  • epoch_mechanism() at line 559: Main epoch function
  • epoch_dense_mechanism() at line 146: Dense matrix variant (testing)
  • compute_bonds() at line 1258: Bond computation
  • compute_ema_bonds_normal() at line 1222: Standard EMA bonds