I underestimated the pain that will be implementing the tip

Stress tests are a bit hole in the current test suite.

A genesis file is required to specify the initial balances in the blockchain (otherwise, not transactions can go through).

• Define the syntax for the genesis file
• Add loading of genesis file (mostly likely using moneySpawn method)
• Basic testing
• Modify setup file to also generate a file that given k coins to each participant (for example)

Update the HDSLedgerService and the NodeService to serve updates to the BankState.

• Replace String* by Bank* and do proper updates to code
• Remove Slot from HDSLedgerService to reduce coupling
• Fix tests
• e2e balance update
  • Optional slotId in Slot
• Load genesis file #27
• Add checkBalance
• e2e balance check

Currently, byzantine behaviour tests are a bit cumbersome. A small refactor is required to improve the system's testability

Currently, messages for future rounds are stashed, but never picked up later on

Hash is probably taking too much space and reducing maximum batch size

May have unnecessary key generation

Remove clients from config. Clients should initiate connections and they are identified by their public key in the remaining system.

Parameters such as the batch size, batch formation timeout and the starting timeout for QBFT should be settable by environment variables (this might apply to more constants in the system).

• Add three byzantine handlers
  • If leader, only propose after half the timeout has elapsed
  • If leader, proposed incorrectly signed transaction
  • If leader, only propose after half the timeout has elapsed and proposed incorrectly signed transaction
• Change NodeService to be able to be instantiaded with one of these byzantine handlers (just add a new constructor that takes some enum that specifies the byzantin hook)
• Change the main class to read from the terminal which version to instantiate (default is good replica, but one of the other three options can be specified)

Have flag in SigningUtils that allows for dummy cryptography to check impact of signatures in protocol performance

The bash script to generate the PKI and the config is broken

The protocol doesn't require that all messages are justified with more than a quorum. The only requirement is that the set of messages, as a set is justified. However, any good node sends a quorum of justifications whenever a value is sent. For this reason, the extra complacency is not required and can thus be factored out for better performance.

Probably best to make sure we have non-repudiation

Factor ledger state into a proper class.
This should avoid doing serialization and deserialization of state manually and will prove useful in the second part of the project

Since HMACs are in place, there's no need to use signatures for balance checks.

Currently, any test that requires any signing/keys needs to generate the keys itself. It would be great to find a design for the testing suite that avoid this redundant and time-consuming operation.

Currently tests are just redefining the same message creating functions over and over. This should be factored to a single class

The last rule of the round-change mechanism is missing, which compromises the system's liveness

Currently, APLink is not a perfectly authenticated link, but rather a perfect link only. For this reason a renaming should be done

Currently, highestPrepared is vulnerable to Byz that send values that are too high (as the messages all go into a single set/bucket)
This needs to be fixed. Might imply changes to other parts of the code as well

This deduplication is done in justifyRoundChange but not in justifyPrePrepare, which open a security hole

Organization (package-wise) of message classes is poorly organized. Should be improved