5 posts tagged with "full-leios"

This week, the Leios team made significant progress in protocol development, focusing on simulation improvements, network protocol design, and economic analysis. The team completed extensive simulations across 648 scenarios, implemented new mini-protocols for Leios diffusion, and conducted important economic analysis regarding future reward sustainability.

Simulation and analysis​

• Completed comprehensive simulation of 648 scenarios for Full and Short Leios at tag leios-2025w16
• Generated new analysis outputs:
  • Network, disk, and CPU resource usage summaries
  • Interactive "Leios graph" visualization showing transaction, IB, EB, RB, and vote linkages
• Key findings from simulations:
  • Strong agreement between Rust and Haskell implementations
  • Haskell simulation shows network congestion at 16 IB/s
  • Rust simulation demonstrates higher CPU usage at elevated IB rates
  • Identified voting certification issues in Rust implementation.

Protocol development​

Haskell implementation​

• Completed first draft of new mini-protocols for Leios diffusion:
  • IB-relay, EB-relay, Vote-relay for header diffusion
  • IB-fetch, EB-fetch for body diffusion
  • CatchUp protocol for historical blocks
• Renamed short-leios command to leios to reflect full variant support.

Rust implementation​

• Fixed conformance with shared trace format
• Resolved voting logic bug affecting EB certification
• Updated visualization system for documentation site integration.

Economic analysis​

The team conducted a detailed analysis of transaction lifecycle and future reward sustainability:

• Analyzed seven stages of Full Leios transaction processing
• Identified optimal stage lengths and shard configurations
• Estimated two-minute average delay from transaction submission to RB reference
• Projected future IB rates needed to maintain current reward levels:
  • Current Reserve depletion rate: 12.8% per year
  • Required IB rates increase from 0.008 to 0.634 blocks/slot by 2035
  • Analysis assumes constant fee-related protocol parameters.

Next steps​

• Translate transaction lifecycle model to Delta QSD for network effects analysis
• Compare model results with Rust simulator output
• Develop memory-pool and ledger variant models
• Continue investigation of voting certification issues in Rust implementation.

This week, the team made substantial progress in both the Haskell and Rust simulations, refined cost estimates, and carried out detailed analyses of the transaction lifecycle and Full Leios simulations.

Simulation improvements​

Haskell simulation​

• Completed the first draft of new mini protocols for Leios diffusion
  • Modeled protocols after block-fetch and node-to-node transaction submission from ouroboros-network
  • Included IB relay, EB relay, and vote relay for header diffusion and body announcements
  • Included IB fetch and EB fetch for body diffusion
  • Worked on the CatchUp protocol for older blocks
  • See simulation/docs/network-spec for full protocol details
• Renamed short-leios command to leios as it now covers the full variant as well
  • short-leios is kept as alias for compatibility.

Rust simulation​

• Fixed conformance issues with the shared trace format
• Fixed a bug in the voting logic that prevented EBs from receiving enough votes to be included on-chain
• Updated visualizations to use smaller trace files in preparation for hosting on the documentation site.

Revisions to the cost dashboard​

The cost dashboard was updated with lower and more realistic IO estimates.

Transaction lifecycle analysis​

The Jupyter notebook Analysis of transaction lifecycle estimates the delay introduced at each of the seven stages of Full Leios as a transaction progresses from the memory pool to being referenced by a Praos block.

Key findings from the analysis:

1. Reducing stage lengths below 10 slots offers little benefit
2. The number of shards should remain low enough to maintain a high IB rate per shard relative to the stage length
3. Low EB rates result in many orphaned IBs
4. With realistic parameters, the delay from transaction submission to its inclusion in an RB is approximately two minutes.

Potential next steps:

• Translate the model into Delta QSD to capture network effects
• Compare the model's output with results from the Rust simulator
• Extend the model to account for different memory pool and ledger variants under evaluation.

Simulation and analysis of Full Leios​

The team conducted comprehensive simulations using both Haskell and Rust simulators at tag leios-2025w16. The simulations covered 648 scenarios of Full and Short Leios with varied parameters:

• IB production rate
• IB size
• EB production rate
• Stage length
• CPU constraints.

Two new output files were generated:

1. A summary of network, disk, and CPU resource usage over the course of the simulation
2. The vertices and edges of the Leios graph, showing linkages between transactions, IBs, EBs, RBs, and votes (can be visualized as an interactive web page).

Key findings:

• The Rust and Haskell simulations show generally close agreement
• The Haskell simulation encounters network congestion at 16 IB/s, while the Rust simulation does not
• The Rust simulation consumes more CPU at high IB rates than the Haskell simulation
• In some cases, the Rust simulation does not produce enough votes to certify an EB.

Detailed results are available in the Jupyter notebook analysis/sims/2025w16/analysis.ipynb.

This week, the Leios team continued working on various aspects of the protocol and its simulation capabilities. They made progress in implementing and testing the Haskell and Rust simulators, focusing on protocol behavior under different network conditions.

Simulation progress​

• Haskell simulation

  • Moved configuration and topology parsers to the leios-trace-hs package for reuse in formal methods
  • Investigated differences in IBs referenced with Rust simulation: identified that inconsistencies were caused by the same sequence of random samples being used across different runs
  • Simplified sortition code by using an external statistics package
  • Tested Full Leios, resolving tension between r_EB/eb-max-age-slots and praos-chain-quality/η
  • Fixed cabal run ols -- generate-topology close-and-random, listing producers properly and decreasing variance in upstream peers.

• Rust simulation

  • Investigated anomalies in simulation results: identified that earlier IB production failures were caused by low connectivity and lower CPU usage compared to the Haskell simulation
  • Refined Full Leios implementation
  • Added Full Leios support to the visualizer
  • Migrated the visualizer from Next.js to Vite.

Analysis of simulations​

• Tag leios-2025w13: simulated 198 Short Leios scenarios, varying IB production rate, IB size, network topology, CPU limits, and protocol flags
• CPU limits: analyzed the impact of CPU constraints on IB propagation, finding that diffusion can be affected under stress conditions
• Vote propagation: compared freshest-first and oldest-first vote propagation, with freshest-first potentially improving IB delivery reliability
• Extended voting period: compared an extended voting period to a limited one in the Haskell simulation, observing minimal differences except for occasional improvements in reliable vote delivery.

Ongoing investigations​

• Investigating qualitative discrepancies between Haskell and Rust simulation results to determine whether they stem from differences in simulator resolution or simulation infidelities.

Additional resources​

• Monthly review meeting – March 2025.

This week, the Leios team made significant progress in protocol development, focusing on improving simulation capabilities and analyzing protocol behavior under various network conditions. A comparison of Haskell and Rust simulations across 18 scenarios demonstrated that the Leios protocol scales effectively to mainnet-sized networks. However, congestion occurs when the input block rate reaches 30 IB/s.

Simulation comparison​

• Compared 18 scenarios between Haskell and Rust simulations at tag leios-2025w12
• Recent fixes and adjustments enabled meaningful comparison between simulations
• Identified differences when comparing the Haskell and Rust results, which are under active investigation.

Analysis of simulations​

• Completed the first simulation of Short Leios, evaluating IB production rate, IB size, and network topology
• Demonstrated that the Leios protocol scales effectively to mainnet-sized networks
• Identified congestion occurring when the input block rate exceeds 30 IB/s
• Suggested that allowing IBs larger than current Praos RBs may have advantages in TCP efficiency, network usage, and adapting to fluctuating transaction loads.

Peak CPU	Mean CPU

Haskell simulation​

• Implemented expiration of blocks:
  • Blocks are removed from the relay buffer once diffusion stops and cleared from other states as specified
• Developed an initial Full Leios implementation:
  • Currently in early testing
  • Added the praos-chain-quality configuration parameter for the \eta parameter from the specification.

Rust simulation​

• Developed an initial Full Leios implementation using estimated values for some parameters.

Formal methods​

• Short Leios trace verification: modeling local state evolution of a node
• Developed an initial trace verifier for Short Leios simulation traces in leios-trace-verifier.

This week, the Leios team made significant progress in simulation capabilities, with a successful comparison of Rust and Haskell simulations across 90 scenarios. A mainnet-scale analysis of Leios on a realistic 3,000-node network revealed unexpected performance benefits from network topology. Insights from sharding performance analysis provided important optimization strategies. Finally, the team refined both simulation implementations for greater realism and comparability, while the formal methods team developed initial trace verification tools for Short Leios.

Simulation comparison​

• Compared 90 scenarios between Rust and Haskell simulations at tag leios-2025w11
• Recent fixes and adjustments enabled meaningful comparison between simulations
• Identified issues requiring further investigation.

Analysis of mainnet-scale simulation​

• Completed the first analysis of Leios on a mainnet-scale network simulation using the Rust simulator
• Discovered that a 3,000-node mainnet-scale network transports IBs faster than an artificial 100-node network
• Identified 'shortcut' edges in larger networks as a likely factor in the improved transport speed.

Performance analysis of sharding​

• Created computational models to analyze the relationship between the fraction of shards without an IB and the expected number of extra IBs
• Evaluated performance characteristics of the simplest sharding scheme.

Haskell simulation​

• Fixed a bug in the relay protocol that prevented full diffusion of votes
• Adjusted the priority of certified EBs for inclusion in RBs
• Added support for an output log format that shares a common subset with the Rust simulator
• Analyzed TCP realism in comparison to idealized diffusion:
  • Discovered that higher IB rates and sizes improve diffusion times
  • Identified ledger state access as a significant source of latency.

Rust simulation​

• Expanded logs to include total IB size and parent ID of RBs
• Implemented the same EB selection strategy as in the Haskell simulation
• Added validation of IB headers before propagation to neighbors
• Investigating lower congestion in the Rust simulation compared to Haskell.

Formal methods​

• Developed the initial trace verifier for Short Leios simulation traces in leios-trace-verifier.

Research​

• Progressing on ledger design by exploring options and trade-offs
• Analyzing how concurrent input blocks in Leios create unique ledger-level challenges not present in Praos
• Evaluating approaches that balance multiple properties, including:
  • Conflict avoidance in the blockchain
  • Guaranteed fee payment for block producers
  • Transaction eligibility and inclusion speed
  • User experience regarding fee payment
• Investigating sharding-based solutions with various optimization strategies
• Planning to share more detailed findings at Leios public meeting by the end of March
• Targeting a comprehensive recommendation for implementors by the end of April.

From Short Leios to Full Leios​

• Planning the simulation roadmap for transitioning from Short Leios (currently implemented) to Full Leios
• Developing implementation guidelines for simulators to incorporate the pipeline referencing scheme specified in the papers
• Identifying key components needed to simulate the complete ledger inclusion guarantees of Full Leios.