For single era blocks, it would be the same to hold a stowed ledger state (LedgerTables (LedgerState blk) EmptyMK), an unstowed one (LedgerTables (LedgerState blk) ValuesMK) or a tuple with the state and the tables (LedgerState blk EmptyMK, LedgerTables (LedgerState blk) ValuesMK), however, for a hard fork block, these are not equivalent.

If we were to hold a sequence of type LedgerState blk EmptyMK with stowed values, we would have to translate the entirety of the tables on epoch boundaries.

If we were to hold a sequence of type LedgerState blk ValuesMK we would have the same problem as the mk in the state actually refers to the mk in the HardForkState'ed state.

Therefore it sounds reasonable to hold a LedgerState blk EmptyMK with no values, and a LedgerTables blk ValuesMK next to it, that will live its entire lifetime as LedgerTables of the HardForkBlock.

Creates an empty LedgerSeq

Creates an empty LedgerSeq

Extending the LedgerDB with a valid ledger state.

>>> ldb            = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> LedgerSeq ldb' = extend l4 ldb
>>> AS.toOldestFirst ldb' == [l1, l2, l3, l4]
True

Prune older ledger states until at we have at most k volatile states in the LedgerDB, plus the one stored at the anchor.

The fst component of the returned value has to be closeed.

>>> ldb  = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> ldb' = LedgerSeq $ AS.fromOldestFirst     l1 [l2, l3]
>>> snd (prune (LedgerDbPruneKeeping (SecurityParam (unsafeNonZero 2))) ldb) == ldb'
True

When creating a new LedgerDB, we should load whichever snapshot we find and then replay the chain up to the immutable tip. When we get there, the LedgerDB will have a k-long sequence of states, which all come from immutable blocks, so we just prune all of them and only keep the last one as an anchor, as it is the immutable tip. Then we can proceed with opening the VolatileDB.

If we didn't do this step, the LedgerDB would accept rollbacks into the immutable part of the chain, which must never be possible.

>>> ldb  = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> LedgerSeq ldb' = snd $ pruneToImmTipOnly ldb
>>> AS.anchor ldb' == l3 && AS.toOldestFirst ldb' == []
True

Apply a block on top of the ledger state and extend the LedgerSeq with the result ledger state.

The fst component of the result should be closed as it contains the pruned states.

The ledger state at the anchor of the Volatile chain (i.e. the immutable tip).

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> l0s == anchor ldb
True

The ledger state at the tip of the chain

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> l3s == current ldb
True

Get a past ledger state

$O(\log(\min(i,n-i))$

When no ledger state (or anchor) has the given Point, Nothing is returned.

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> getPastLedgerAt (Point (At (Block 4 4)) :: Point B) ldb == Nothing
True
>>> getPastLedgerAt (Point (At (Block 1 1)) :: Point B) ldb == Just l2s
True

Have we seen at least k blocks?

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> isSaturated (SecurityParam (unsafeNonZero 3)) ldb
True
>>> isSaturated (SecurityParam (unsafeNonZero 4)) ldb
False

How many blocks can we currently roll back?

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> maxRollback ldb
3

Get a prefix of the LedgerDB that ends at the given point

$O(\log(\min(i,n-i))$

When no ledger state (or anchor) has the given Point, Nothing is returned.

Rollback n ledger states.

Returns Nothing if maximum rollback (usually k, but can be less on startup or under corruption) is exceeded.

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> fmap (([l1] ==) . AS.toOldestFirst . getLedgerSeq) (rollbackN 2 ldb)
Just True

Rollback the volatile states up to the volatile anchor.

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> LedgerSeq ldb' = rollbackToAnchor ldb
>>> AS.anchor ldb' == l0 && AS.toOldestFirst ldb' == []
True

Roll back the volatile states up to the specified point.

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> Just (LedgerSeq ldb') = rollbackToPoint (Point Origin) ldb
>>> AS.anchor ldb' == l0 && AS.toOldestFirst ldb' == []
True
>>> rollbackToPoint (Point (At (Block 1 2))) ldb == Nothing
True
>>> Just (LedgerSeq ldb') = rollbackToPoint (Point (At (Block 1 1))) ldb
>>> AS.anchor ldb' == l0 && AS.toOldestFirst ldb' == [l1, l2]
True

All snapshots currently stored by the ledger DB (new to old)

This also includes the snapshot at the anchor. For each snapshot we also return the distance from the tip.

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> [(0, l3s), (1, l2s), (2, l1s)] == snapshots ldb
True

Reference to the block at the tip of the chain

>>> ldb = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> tip ldb == getTip l3s
True

Transform the underlying volatile AnchoredSeq using the given functions.