Skip to main content

Weekly Summary – April 7, 2025

· 3 min read
William Wolff
Architect

This week, the team continued refining the protocol and its simulation capabilities, making significant progress in addressing various topics.

Simulation improvements

Haskell simulation

  • Started specifying a new relay protocol for IB header diffusion without the body
  • Improved the shared log format by removing redundancies and harmonizing naming
  • Added support for additional events required by conformance testing, including SlotEvent and NoBlockEvent
    • These events can be enabled using the --conformance-events flag with --shared-log-format.

Rust simulation

  • Updated traces to match the new standardized trace format
  • Fixed a critical bug in CPU scheduling where nodes were using more cores than allocated.

Analysis of workflow optimization

The team significantly improved the workflow for analyzing both Haskell and Rust simulations:

  • Replaced MongoDB with more efficient jq queries using map-reduce operations
  • Created reusable library functions for plotting with R
  • Revised and streamlined scripts for creating, executing, and analyzing simulations
  • Made the Jupyter notebook for analyses more generic and reusable
  • Successfully tested the new workflow on tag leios-2025w15.

These improvements will enable faster setup and execution of future simulation experiments, with quicker turnaround times for analysis. During this optimization work, several discrepancies between the Haskell and Rust simulations were identified and documented as GitHub issues for future investigation.

Edinburgh workshop recaps

The Edinburgh workshop documentation has been made available, covering key discussions and decisions:

Day 1 highlights

  • Explored ledger design options comparing labeled UTXOs (explicit shards) vs accounts (implicit shards) approaches
  • Discussed conformance testing strategies including QuickCheck dynamic and trace verification approaches
  • Analyzed critical edge cases for user onboarding and system properties.

Day 2 highlights

  • Conducted a detailed analysis of Leios node costs across different TPS levels
  • Key findings on resource usage:
    • At 10 TPS: 1.8x increase in egress and 6x increase in compute compared to Praos
    • At 1K TPS: significant scaling improvements with better resource efficiency
  • Provided recommendations for potential integration with Peras, particularly to optimize the voting mechanism
  • Discussed performance characteristics at both high and low throughput levels.

Day 3 highlights

  • Held an in-depth discussion on optimistic ledger state references, exploring three main approaches:
    1. RB reference: highest security but highest latency
    2. EB reference: balanced approach with medium security and latency
    3. EB-DAG: advanced approach using directed acyclic graph structure
  • Key advantages of the EB-DAG approach:
    • Achieves low latency while maintaining security
    • Provides strong inclusion guarantees for EBs
    • Enables efficient state management and reconstruction
    • Creates a complete, verifiable chain history
  • Discussed implementation considerations for state management and block ordering under the EB-DAG model.

For more information, please see the full workshop recaps in the Leios documentation.

Weekly Summary – March 31, 2025

· 3 min read
William Wolff
Architect

This week, the Leios team met for an in-person workshop in Edinburgh and continued their efforts in refining the protocol and its simulation capabilities. The team made significant progress in addressing various topics.

On day one, the team discussed topics such as ledger design and trade-offs, as well as two different ways to link the formal specification to the simulations. They explored various ledger design options, including labeled UTXOs and accounts approaches, with detailed consideration of fees, collateral, and conflict prevention mechanisms. The team also discussed conformance testing approaches, including QuickCheck dynamic and trace verification methods.

On day two, the team made significant progress towards estimating the cost of running a Leios node, considering different cost items such as network egress, CPU, and storage. They analyzed resource usage across different TPS levels, from 10 TPS to 1K TPS, and discovered that while there’s significant overhead at low throughput, the protocol becomes more efficient at higher TPS levels. The team hasn’t been able to finish all the cost items yet. The last two, IOPS and memory cost, will be added during this month.

On the last and third day, the team consolidated their options for how optimistic validation of input blocks can be accomplished. They defined three candidates, with one being favored. The main goal was to support the chaining of transactions with Leios, which requires defining a 'point in time' or stage of the protocol at which a subsequent or chained transaction can be built on top of an already submitted transaction. This can be achieved by having the node optimistically compute prospective ledger states using its local knowledge of input blocks referenced in certified endorser blocks or possibly ranking blocks.

Simulation progress

  • Haskell simulation
    • Added support for dishonest nodes that diffuse an unbounded amount of old IBs, enabling further analysis of freshest-first and oldest-first vote delivery scenarios
    • Identified and fixed a bug in configuration generation for simulation runs, which was causing inconsistencies in vote delivery between default and uniform/extended voting schemes
    • Added an adversarial field to the network topology schema, allowing for the simulation of unbounded IB diffusion by dishonest nodes.

Ongoing investigations

  • Investigating the effects of unbounded IB diffusion on IB delivery reliability and protocol performance under such conditions
  • Working on quantifying settlement times and their impact on protocol performance
  • Exploring integration possibilities with Ouroboros Peras, mainly focusing on potentially reusing their voting mechanism to reduce resource consumption.

Additional resources

Weekly Summary – March 24, 2025

· 2 min read
William Wolff
Architect

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

Weekly Summary – March 17, 2025

· 2 min read
William Wolff
Architect

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 CPUMean CPU
analysis/sims/2025w12xl/plots/cpu-peak-histogram-rust.pnganalysis/sims/2025w12xl/plots/cpu-mean-histogram-rust.png

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.

Weekly Summary – March 10, 2025

· 3 min read
William Wolff
Architect

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.

In-flight time for input blocks (IBs)

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.

Performance analysis of simple sharding

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.

Weekly Summary – March 3, 2025

· 2 min read
William Wolff
Architect

This week in Leios development, the team focused on simulation analysis, formal methods, and documentation updates. Key accomplishments include in-depth analysis of simulations at tag leios-2025w10, advancements in formal methods through a working trace verifier, and the development of technical reports.

Cross-simulation analysis

  • Completed a comprehensive analysis of simulations at tag leios-2025w10:
    • Analyzed Haskell simulation performance with and without CPU usage considerations
    • Varying key protocol parameters:
      • IB production rate
      • IB size
      • Length of Leios stages
    • Identified the following aspects of Leios:
      • Delay between IB generation and receipt at nodes
      • Peak and mean CPU usage over time
      • Breakdown of CPU usage by task type
      • Sizes of IBs, EBs, and RBs
      • Duplicate IB references in EBs
      • Reference to EBs from RBs
      • Resource utilization in network traffic.

Protocol and formal methods

  • Began developing a trace verifier in Agda:
    • Implemented event trace parsing using the Haskell module leios-trace-hs.

Documentation and research

Programming and testing

Rust simulation visualization

  • Improved visualization capabilities:
    • Added support for multiple predefined 'scenarios' instead of single hard-coded trace
    • Moved the visualization logic to the client-side web worker for better performance
    • Added the visualization of per-node network traffic breakdown by message type
  • Fixed critical simulation bugs:
    • Resolved issue #229 causing time travel and crashes in high-traffic high-latency scenarios.

Weekly Summary – February 24, 2025

· 2 min read
William Wolff
Architect

This week in Leios development, the team focused on simulation analysis and formal methods. Key accomplishments include detailed analyses of both Haskell and Rust simulations, initial work on a protocol dashboard, and advancements in formal methods through trace verification in Agda.

Cross-simulation analysis

  • Completed a comprehensive analysis of simulations at tag leios-2025w09:
    • Refactored the ELT workflow to improve simulation data processing
    • Modified the Rust simulator to generate fixed-size input blocks (IBs) for comparison with Haskell
    • Partially resolved discrepancies in congestion metrics between simulators
    • Developed detailed analyses of:
      • IB generation to receipt elapsed time
      • Time-in-flight over node-to-node links
    • Identified the dual role of network bandwidth and CPU bottlenecks in high throughput congestion.

Protocol dashboard initiative

  • Initiated the design of an interactive protocol dashboard with planned features:
    • Protocol parameter configuration
    • Stake distribution settings
    • Performance visualization:
      • Block arrival efficiency
      • Transaction duplication
      • Leios operation rewards
      • Resource utilization
    • Security metrics visualization:
      • Quorum failure analysis
      • Certificate forgery detection
      • Adversarial block tracking.

Rust simulation

  • Enhanced parallel message handling capabilities:
    • Implemented parallel mini-protocol message transmission
    • Added even bandwidth distribution between mini-protocols
    • Introduced the simulate-transactions configuration option
    • Updated simulation output for better Haskell compatibility
    • Improved block visualization for scenarios with high IB counts.

Formal methods

  • Commenced trace verifier development in Agda:
    • Added decidability to Short Leios protocol relational specification
    • Implemented a proof-by-computation approach for execution traces
    • Applied the successful methodology from Streamlet formalization.

Weekly Summary – February 17, 2025

· 2 min read
William Wolff
Architect

This week in Leios development, CPS-0018 for transaction throughput was approved, along with improved Docker support for simulations and analysis of cross-simulation results. The team also examined input block (IB) production rates and their impact on network performance.

Protocol development

  • CPS-0018 'Greater transaction throughput' officially approved:
    • Merged into Cardano Foundation's CIP/CPS repository
    • Documents urgency of higher transaction throughput
    • Defines goals for the Leios initiative
    • Identifies key open questions and use cases.

Cross-simulation analysis

  • Conducted a comprehensive analysis of IB production rates ranging from 1 IB/s to 100 IB/s:
    • Developed an ELT workflow for data processing via MongoDB
    • Created an R Jupyter notebook for analysis and visualization
    • Identified and addressed three significant bugs (#207, #208, #209)
  • Key findings from the Haskell simulation:
    • Network congestion emerges at high IB production rates
    • Both average propagation time and slow propagation tail increase
    • A critical threshold of ~40 IBs/s was identified, beyond which network congestion severely impacts block reception
  • Comparison of PeerNet and Haskell simulations:
    • Both exhibit qualitatively similar block propagation distributions
    • Both demonstrate protocol breakdown under high block production rates
    • Differences in resolution and configuration prevent exact comparison.

Infrastructure improvements

  • Added comprehensive Docker support for both simulations:
    • Optimized multi-stage Docker files for Haskell and Rust
    • Simplified deployment process
    • Enabled easy configuration via volume mounts and parameters
    • Documented usage in README.md.

Rust simulation

  • Enhanced Rust simulation capabilities:
    • Implemented bandwidth usage tracking
    • Added configurable bandwidth limits per connection
    • Fixed issues identified in cross-simulation comparisons
    • Started updating visualizations for improved clarity.

Haskell simulation

  • Enhanced IB sortition handling for IB/slot < 1
  • Began integrating block expiration and diffusion-halt proposal
  • Implemented ideal timing calculations for diffusion:
    • Added uniform block behavior configuration
    • Identified relay mini-protocol complexities:
      • Variable latency (3-4) for block transfer
      • Latency depends on traffic conditions and request handling.

Formal methods

  • Moved formal specification to a dedicated repository
  • Established a conformance testing framework:
    • Enabled testing between Short Leios implementations
    • Documented the test suite execution process
  • Initiated a survey of network models across IO consensus projects.

Weekly Summary – February 10, 2025

· 3 min read
William Wolff
Architect

This week, the Leios team made significant progress across multiple areas. Major developments included detailed DeltaQ analysis of network topologies, extensive BLS cryptography benchmarking, and improvements to both simulations. The team also explored succinct schemes for BLS key registration and conducted a detailed certificate performance analysis. Both Haskell and Rust simulations received substantial updates to improve visualization and support more realistic testing conditions.

DeltaQ analysis

  • Enhanced the topology-checker with ΔQSD analysis capabilities:
    • Extracts inter-node latencies from given topologies
    • Classifies latencies into near/far components
    • Builds parameterized ΔQ models
    • Outputs fitted models in delta_q web app syntax
  • Key findings from topology analysis:
    • Clear distinction between near/far components in examined topologies
    • Unexpectedly high hop counts in latency-weighted Dijkstra paths:
      • Min 4-5, max 8 for topology - 100
      • Min 8, max 20 for 'realistic' topology
    • Model fitting achieved rough shape matching but showed significant deviations at low latencies
    • Resource usage tracking goals remain unmet due to complexity in understanding load multiplication factors.

BLS cryptography

  • Completed comprehensive benchmarking of certificate operations:
    • Detailed performance analysis across committee sizes (500-1000 seats)
    • Certificate generation: 63.4ms - 92.5ms
    • Certificate verification: 104.8ms - 144.9ms
    • Certificate weighing: ~12ms consistently
  • Explored succinct schemes for key registration:
    • Proposed 90-day key evolution with 124-byte KZG commitments
    • Analyzed message sizes for key opening (316 bytes per pool)
    • Investigated SNARK-based alternatives for proof of possession
  • Added BLS crypto to the CI pipeline with automated testing
  • Documented parallelization strategies for certificate operations.

Formal methods

  • Added a conformance testing client for the executable Short Leios specification
  • Successfully merged the executable specification for Simplified Leios into main.

Haskell simulation

  • Updated configuration defaults for block sizes and timings
  • Added support for idealized simulation conditions:
    • Single-peer block body requests
    • TCP congestion window modeling
    • Mini-protocol multiplexing
    • Unlimited bandwidth links support
  • Enhanced simulation output and analysis:
    • Added raw field for accumulated data
    • Implemented block diffusion CDF extraction
    • Created multi-CDF plotting capabilities.

Rust simulation

  • Enhanced visualization capabilities:
    • Added block size breakdown display
    • Implemented total bytes sent/received tracking
    • Added total TX count and CPU time metrics
  • Improved event handling:
    • Updated to standard timestamp format (seconds)
    • Enhanced CPU task event structure
    • Added CBOR output support
  • Added support for multiple strategies:
    • Implemented ib-diffusion-strategy (freshest-first, oldest-first, peer-order)
    • Added relay-strategy affecting TXs, IBs, EBs, votes, and RBs
    • Enabled unlimited EB and vote bundle downloads from peers.

Weekly Summary – February 3, 2025

· 2 min read
William Wolff
Architect

This week, the Leios team worked on cryptography benchmarking and cost calculator improvements. The team completed a reference implementation for Leios cryptography and enhanced the online cost calculator with user-requested features. They also updated both Haskell and Rust simulations to improve visualization and network modeling capabilities.

Haskell simulation

  • Added support for Send and Receive voting stages, providing:
    • A new leios-vote-send-recv-stages configuration option
    • A configurable stage length via leios-stage-active-voting-slots
  • Implemented multiple diffusion strategies:
    • Added oldest-first strategy
    • Added configurable strategies for IBs, EBs, and votes via *-diffusion-strategy configurations
  • Created a new small scenario for 100 nodes with 2,000 kB links
    • Tuned IB parameters to utilize one-third of link capacity
    • Added configurations for both single-stage and send-recv voting
  • Fixed several simulation behaviors:
    • Improved block generation logic
    • Prevented duplicate EB inclusion in the base chain
    • Confirmed proper EB inclusion timing relative to vote diffusion
  • The main difference observed between single-stage and send-recv is that the former shows a longer tail in the CPU usage CDF when the simulation is run with unlimited cores.

Cryptography implementation

The Rust benchmarks for Leios cryptography were redesigned as a reference implementation:

  • Implemented the Fait Accompli sortition
  • Enhanced sortition to use rational arithmetic instead of quad-precision floats
  • Added Quickcheck tests for all capabilities
  • Added benchmarks for serialization
  • Optimized vote and certificate size.

Cost calculator improvements

The team enhanced the online Leios cost calculator:

  • Added support for both hyperscale and discount cloud providers
  • Made discount providers the default option
  • Added option to amortize storage costs perpetually
  • Updated defaults:
    • Single relay deployment
    • More conservative 50% disk compression
    • Perpetual storage cost amortization.

Throughput simulator

The team updated the Cardano throughput simulator with:

  • The latest cloud-computing cost model
  • Synchronized assumptions with an online cost calculator.

Rust simulation

  • Made minor fixes to the new graph generation strategy
  • Planned out a roadmap for visualization work focusing on the Leios transaction lifecycle.