The interface fulfilled by handles on both the InMemory and LSM handles.

The most relevant concept is handle duplication:

A duplicated handle must provide access to all the data that was there in the original handle while being able to mutate in ways different than the original handle.

When applying diffs to a table, we will first duplicate the handle, then apply the diffs in the copy. It is expected that duplicating the handle takes constant time.

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.

Close all LedgerTablesHandle in this LedgerSeq, in particular that on the anchor.

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 according to the given LedgerDbPrune strategy.

The fst component of the returned value is an action closing the pruned ledger states.

>>> ldb  = LedgerSeq $ AS.fromOldestFirst l0 [l1, l2, l3]
>>> ldb' = LedgerSeq $ AS.fromOldestFirst     l1 [l2, l3]
>>> snd (prune (LedgerDbPruneBeforeSlot 1) ldb) == ldb'
True

where lX is a ledger state from slot X-1 (or Origin for l0).

Set the volatile tip as the immutable tip and prune all older states.

>>> 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 run to close 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.