Fields

• cdbImmutableDB :: !(ImmutableDB m blk)
   
• cdbVolatileDB :: !(VolatileDB m blk)
   
• cdbLgrDB :: !(LgrDB m blk)
   
• cdbChain :: !(StrictTVar m (AnchoredFragment (Header blk)))

  Contains the current chain fragment.

  INVARIANT: the anchor point of this fragment is the tip of the ImmutableDB. This implies that this fragment never contains any blocks that are stored in the immutable DB.

  Note that this fragment might be shorter than k headers when the whole chain is shorter than k or in case of corruption of the VolatileDB.

  Note that this fragment might also be longer than k headers, because the oldest blocks from the fragment might not yet have been copied from the VolatileDB to the ImmutableDB.

  The anchor point of this chain should be the most recent "immutable" block according to the protocol, i.e., a block that cannot be rolled back.

  Note that the "immutable" block isn't necessarily at the tip of the ImmutableDB, but could temporarily still be on the in-memory chain fragment. When the background thread that copies blocks to the ImmutableDB has caught up, the "immutable" block will be at the tip of the ImmutableDB again.

  Note that the "immutable" block might be less than k blocks from our tip in case the whole chain is shorter than k or in case of corruption of the VolatileDB.

  Note that the "immutable" block will never be more than k blocks back, as opposed to the anchor point of cdbChain.

• cdbIterators :: !(StrictTVar m (Map IteratorKey (m ())))

  The iterators.

  This maps the IteratorKeys of each open Iterator to a function that, when called, closes the iterator. This is used when closing the ChainDB: the open file handles used by iterators can be closed, and the iterators themselves are closed so that it is impossible to use an iterator after closing the ChainDB itself.

• cdbReaders :: !(StrictTVar m (Map ReaderKey (ReaderHandle m blk)))

  The readers.

  A reader is open iff its ReaderKey is this Map.

  INVARIANT: the readerPoint of each reader is withinFragmentBounds of the current chain fragment (retrieved cdbGetCurrentChain, not by reading cdbChain directly).

• cdbTopLevelConfig :: !(TopLevelConfig blk)
   
• cdbInvalid :: !(StrictTVar m (WithFingerprint (InvalidBlocks blk)))

  See the docstring of InvalidBlocks.

  The Fingerprint changes every time a hash is added to the map, but not when hashes are garbage-collected from the map.

• cdbNextIteratorKey :: !(StrictTVar m IteratorKey)
   
• cdbNextReaderKey :: !(StrictTVar m ReaderKey)
   
• cdbCopyLock :: !(StrictMVar m ())

  Lock used to ensure that copyToImmutableDB is not executed more than once concurrently.

  Note that copyToImmutableDB can still be executed concurrently with all others functions, just not with itself.

• cdbTracer :: !(Tracer m (TraceEvent blk))
   
• cdbTraceLedger :: !(Tracer m (LedgerDB' blk))
   
• cdbRegistry :: !(ResourceRegistry m)

  Resource registry that will be used to (re)start the background threads, see cdbBgThreads.

• cdbGcDelay :: !DiffTime

  How long to wait between copying a block from the VolatileDB to ImmutableDB and garbage collecting it from the VolatileDB

• cdbGcInterval :: !DiffTime

  Minimum time between two garbage collections. Is used to batch garbage collections.

• cdbKillBgThreads :: !(StrictTVar m (m ()))

  A handle to kill the background threads.

• cdbChunkInfo :: !ChunkInfo
   
• cdbCheckIntegrity :: !(blk -> Bool)
   
• cdbCheckInFuture :: !(CheckInFuture m blk)
   
• cdbBlocksToAdd :: !(BlocksToAdd m blk)

  Queue of blocks that still have to be added.

• cdbFutureBlocks :: !(StrictTVar m (FutureBlocks blk))

  Blocks from the future

  Blocks that were added to the ChainDB but that were from the future according to CheckInFuture, without exceeding the clock skew (inFutureExceedsClockSkew). Blocks exceeding the clock skew are considered to be invalid (InFutureExceedsClockSkew) and will be added cdbInvalid.

  Whenever a block is added to the ChainDB, we first trigger chain selection for all the blocks in this map so that blocks no longer from the future can get adopted. Note that when no blocks are added to the ChainDB, we will not actively trigger chain selection for the blocks in this map.

  The number of blocks from the future is bounded by the number of upstream peers multiplied by the max clock skew divided by the slot length.

Fields

• intCopyToImmutableDB :: m (WithOrigin SlotNo)

  Copy the blocks older than k from to the VolatileDB to the ImmutableDB and update the in-memory chain fragment correspondingly.

  The SlotNo of the tip of the ImmutableDB after copying the blocks is returned. This can be used for a garbage collection on the VolatileDB.

• intGarbageCollect :: SlotNo -> m ()

  Perform garbage collection for blocks <= the given SlotNo.

• intUpdateLedgerSnapshots :: m ()

  Write a new LedgerDB snapshot to disk and remove the oldest one(s).

• intAddBlockRunner :: m Void

  Start the loop that adds blocks to the ChainDB retrieved from the queue populated by addBlock. Execute this loop in a separate thread.

• intKillBgThreads :: StrictTVar m (m ())

  A handle to kill the background threads.

Fields

• rhSwitchFork :: Point blk -> AnchoredFragment (Header blk) -> STM m ()

  When we have switched to a fork, all open Readers must be notified.

• rhClose :: m ()

  When closing the ChainDB, we must also close all open Readers, as they might be holding on to resources.

  Call rhClose will release the resources used by the Reader.

  NOTE the Reader is not removed from cdbReaders. (That is done by closeAllReaders).

Fields

• invalidBlockReason :: !(InvalidBlockReason blk)
   
• invalidBlockSlotNo :: !SlotNo
   

Fields

• blockToAdd :: !blk
   
• varBlockWrittenToDisk :: !(StrictTMVar m Bool)

  Used for the blockWrittenToDisk field of AddBlockPromise.

• varBlockProcessed :: !(StrictTMVar m (Point blk))

  Used for the blockProcessed field of AddBlockPromise.

Fields

• newTipPoint :: RealPoint blk

  The new tip of the current chain.

• newTipEpoch :: EpochNo

  The epoch of the new tip.

• newTipSlotInEpoch :: Word64

  The slot in the epoch, i.e., the relative slot number, of the new tip.

• newTipTrigger :: RealPoint blk

  The new tip of the current chain (newTipPoint) is the result of performing chain selection for a trigger block (newTipTrigger). In most cases, we add a new block to the tip of the current chain, in which case the new tip is the trigger block.

  However, this is not always the case. For example, with our current chain being A and having a disconnected C lying around, adding B will result in A -> B -> C as the new chain. The trigger B /= the new tip C.

Fields

• (Point blk)

  Point at which the reader is

• (WithOrigin SlotNo)

  Slot number at the tip of the ImmutableDB

Fields

• (Point blk)

  Point at which the reader is

• (WithOrigin SlotNo)

  Slot number at the tip of the ImmutableDB

Fields

• (AnchoredFragment (Header blk))

  Candidate chain containing headers from the future

• [Header blk]

  Headers from the future, not exceeding clock skew

Fields

• (AnchoredFragment (Header blk))

  Candidate chain containing headers from the future

• [Header blk]

  Headers from the future, exceeding clock skew

Fields

• (Point blk)

  Immutable tip

• (Point blk)

  Tip of the current chain

Fields

• (Point blk)

  Immutable tip

• (Point blk)

  Tip of the current chain

Fields

• (Point blk)

  Immutable tip

• ChunkNo

  Chunk number of the immutable tip