Skip to content

Latest commit

 

History

History
101 lines (91 loc) · 5.46 KB

database.md

File metadata and controls

101 lines (91 loc) · 5.46 KB

Database

Abstractions

  • We created a Database trait abstraction using Rust Stable GATs which frees us from being bound to a single database implementation. We currently use MDBX, but are exploring redb as an alternative.
  • We then iterated on Transaction as a non-leaky abstraction with helpers for strictly-typed and unit-tested higher-level database abstractions.

Codecs

  • We want Reth's serialized format to be able to trade off read/write speed for size, depending on who the user is.
  • To achieve that, we created the Encode/Decode/Compress/Decompress traits to make the (de)serialization of database Table::Key and Table::Values generic.
  • We implemented that trait for the following encoding formats:
    • Ethereum-specific Compact Encoding: A lot of Ethereum datatypes have unnecessary zeros when serialized, or optional (e.g. on empty hashes) which would be nice not to pay in storage costs.
      • Erigon achieves that by having a bitfield set on Table "PlainState which adds a bitfield to Accounts.
      • Akula expanded it for other tables and datatypes manually. It also saved some more space by storing the length of certain types (U256, u64) using the modular_bitfield crate, which compacts this information.
      • We generalized it for all types, by writing a derive macro that autogenerates code for implementing the trait. It, also generates the interfaces required for fuzzing using ToB/test-fuzz:
    • Scale Encoding
    • Postcard Encoding
    • Passthrough (called no_codec in the codebase)
  • We made implementation of these traits easy via a derive macro called main_codec that delegates to one of Compact (default), Scale, Postcard or Passthrough encoding. This is derived on every struct we need, and lets us experiment with different encoding formats without having to modify the entire codebase each time.

Table design

Historical state changes are indexed by BlockNumber. This means that reth stores the state for every account after every block that touched it, and it provides indexes for accessing that data quickly. While this may make the database size bigger (needs benchmark once reth is closer to prod).

Below, you can see the table design that implements this scheme:

erDiagram
CanonicalHeaders {
    u64 BlockNumber "PK"
    H256 HeaderHash "Value for CanonicalHeaders"
}
HeaderNumbers {
    H256 BlockHash "PK"
    u64 BlockNumber
}
Headers {
    u64 BlockNumber "PK"
    Header Data
}
BlockBodyIndices {
    u64 BlockNumber "PK"
    u64 first_tx_num
    u64 tx_count
}
Receipts {
    u64 TxNumber "PK"
    Receipt Data
}
Transactions {
    u64 TxNumber "PK"
    TransactionSignedNoHash Data
}
TransactionHash {
    H256 TxHash "PK"
    u64 TxNumber
}
TransactionBlock {
    u64 TxNumber "PK"
    u64 BlockNumber
}
AccountHistory {
    H256 Account "PK"
    BlockNumberList BlockNumberList "List of transitions where account was changed"
}
StorageHistory {
    H256 Account "PK"
    H256 StorageKey "PK"
    BlockNumberList BlockNumberList "List of transitions where account storage entry was changed"
}
AccountChangeSet {
    u64 BlockNumber "PK"
    H256 Account "PK"
    ChangeSet AccountChangeSet "Account before transition"
}
StorageChangeSet {
    u64 BlockNumber "PK"
    H256 Account "PK"
    H256 StorageKey "PK"
    ChangeSet StorageChangeSet "Storage entry before transition"
}
EVM ||--o{ AccountHistory: "Load Account by first greater BlockNumber"
EVM ||--o{ StorageHistory: "Load Storage Entry by first greater BlockNumber"
TransactionHash ||--o{ Transactions : index
Transactions ||--o{ TransactionBlock : index
BlockBodyIndices ||--o{ TransactionBlock : "index"
TransactionBlock ||--o{ BlockBodyIndices : "index"
Headers ||--o{ AccountChangeSet : "unique index"
AccountHistory ||--o{ AccountChangeSet : index
StorageHistory ||--o{ StorageChangeSet : index
Headers ||--o{ StorageChangeSet : "unique index"
BlockBodyIndices ||--o{ Headers : "index"
Headers ||--o{ HeaderNumbers : "Calculate hash from header"
CanonicalHeaders ||--o{ Headers : "index"
Transactions ||--o{ Receipts : index
Loading