Lachesis is designed to easily plug into applications written in any programming language. Developers can focus on building the application logic and simply integrate with Lachesis to handle the replication aspect. Basically, Lachesis will connect to other Lachesis nodes and guarantee that everyone processes the same commands in the same order.
To do this, it uses p2p networking and a DAG aBFT consensus algorithm.
Lachesis is:
- Asynchronous: Participants have the freedom to process commands at different times.
- Leaderless: No participant plays a ‘special’ role.
- Byzantine Fault-Tolerant: Supports one third of faulty nodes, including malicious behavior.
- Final: Lachesis’s output can be used immediately, no need for block confirmations, etc.
TL;DR
Each Lachesis node stores a local acyclic directed graph (DAG) composed of event blocks, each of which contains transactions. The DAG, capturing the happens-before relationship between the events, is used to calculate an exact final order of events – and hence transactions – independently on each node.
Event blocks are divided into confirmed and unconfirmed event blocks. New event blocks are unconfirmed, while event blocks from the past 2-3+ frames are all confirmed, and subsequently ordered by honest nodes.
Consensus results in batches of confirmed event blocks, where each batch of events is called a block. Finalized blocks forming the final chain are calculated from event blocks independently on each node.
Unlike Proof-of-Work, round-robin Proof-of-Stake, coinage Proof-of-Stake, and sync BFT, Lachesis nodes don’t send blocks to each other. Only the events are being synced between nodes. Validators don’t vote on a concrete state of the network; instead, they periodically exchange observed transactions and events with peers.
Unlike Classical consensus, such as pBFT, Lachesis doesn’t use new events in the current election; instead, new events are used to vote for the events in 2-3+ previous virtual elections simultaneously. This leads to a smaller number of created consensus messages, as the same event is reused in different elections.
Hence, Lachesis achieves a lower time to finality and smaller communication overhead compared to synchronous BFT.
With this, you can see why it’s fully decentralized, secured, and yet so fast at about 700,000 transactions per day. It’s more democratic with little interference.
In the real-world, waiting minutes for payments to confirm is a step backwards, especially while standing in a physical store. Likewise for merchants, who don’t want to let a customer leave until their payment has been received.
And that is the problem with blockchain. On average:
- Bitcoin has a 10 minute block time
- Litecoin lowers that by a factor of 4 to 2.5 minutes
- Ethereum’s block time is between 16 seconds
DAGs, or Directed Acyclic Graphs don’t rely on a single, continuously confirmed blockchain. Think of the standard blockchain like a single stick constantly added to and lengthened in a straight line — a DAG functions as a network of interlocking branches growing outwards in multiple directions.
Transactions can be confirmed orders of magnitude faster while remaining decentralised, as each block only needs to confirm the previous transaction.
it is important to note that Fantom has employed Lachesis aBFT consensus protocol ==that can extend to multiple layers within the system. As a result, you need only 1–2 seconds to confirm a transaction.== It’s a highly scalable protocol that ensures fast and high security on the Fantom network.
https://medium.com/fantomfoundation/fantom-lachesis-code-walkthrough-122d7b926225
https://medium.com/fantomfoundation/how-block-times-prevent-widespread-adoption-6ce0dbcf4df0
https://github.com/Fantom-foundation/go-opera/wiki/Lachesis
https://github.com/Fantom-foundation/go-lachesis/wiki/