Safe Haskell  SafeInferred 

Language  Haskell2010 
Synopsis
 type LookupBlockInfo blk = HeaderHash blk → Maybe (BlockInfo blk)
 extendWithSuccessors ∷ ∀ blk. HasHeader blk ⇒ (ChainHash blk → Set (HeaderHash blk)) → LookupBlockInfo blk → ChainDiff (HeaderFields blk) → NonEmpty (ChainDiff (HeaderFields blk))
 maximalCandidates ∷ ∀ blk. (ChainHash blk → Set (HeaderHash blk)) → Maybe Word64 → Point blk → [NonEmpty (HeaderHash blk)]
 data Path blk
 = NotInVolatileDB (RealPoint blk)
  CompletelyInVolatileDB [RealPoint blk]
  PartiallyInVolatileDB (HeaderHash blk) [RealPoint blk]
 computePath ∷ ∀ blk. HasHeader blk ⇒ LookupBlockInfo blk → StreamFrom blk → StreamTo blk → Maybe (Path blk)
 data ReversePath blk
 = StoppedAtGenesis
  StoppedAt (HeaderHash blk) BlockNo
  (ReversePath blk) ::> (HeaderFields blk, IsEBB)
 computeReversePath ∷ ∀ blk. LookupBlockInfo blk → HeaderHash blk → Maybe (ReversePath blk)
 isReachable ∷ ∀ blk. (HasHeader blk, GetHeader blk) ⇒ LookupBlockInfo blk → AnchoredFragment (Header blk) → RealPoint blk → Maybe (ChainDiff (HeaderFields blk))
LookupBlockInfo
type LookupBlockInfo blk = HeaderHash blk → Maybe (BlockInfo blk) Source #
Return the block info for the block with the given hash. Return Nothing
when not in the VolatileDB.
Candidates
extendWithSuccessors ∷ ∀ blk. HasHeader blk ⇒ (ChainHash blk → Set (HeaderHash blk)) → LookupBlockInfo blk → ChainDiff (HeaderFields blk) → NonEmpty (ChainDiff (HeaderFields blk)) Source #
Extend the ChainDiff
with the successors found by maximalCandidates
.
In case no successors were found, the original ChainDiff
is returned as a
singleton.
In case successors were found, the original ChainDiff
is not
included, only its extensions.
Only the longest possible extensions are returned, no intermediary prefixes of extensions.
∷ ∀ blk. (ChainHash blk → Set (HeaderHash blk))  filterByPredecessor 
→ Maybe Word64  Optional max length of any candidate, used during initial chain selection when LoE is enabled. 
→ Point blk  B 
→ [NonEmpty (HeaderHash blk)]  Each element in the list is a list of hashes from which we can
construct a fragment anchored at the point 
Compute the maximal candidates starting at the specified point
As discussed in the Consensus Report, the set of maximal candidates doesn't include prefixes.
PRECONDITION: the block to which the given point corresponds is part of the VolatileDB.
The first element in each list of hashes is the hash after the specified hash. Thus, when building fragments from these lists of hashes, they fragments must be anchored at the specified hash, but not contain it.
NOTE: it is possible that no candidates are found, but don't forget that
the chain (fragment) ending with B
is also a potential candidate.
Path
A path through the VolatileDB from a StreamFrom
to a StreamTo
.
Invariant: the AnchoredFragment
(oldest first) constructed using the blocks
corresponding to the points in the path will be valid, i.e., the blocks
will fit onto each other.
NotInVolatileDB (RealPoint blk)  The 
CompletelyInVolatileDB [RealPoint blk]  A complete path, from start point to end point was constructed from the VolatileDB. The list contains the points from oldest to newest.

PartiallyInVolatileDB (HeaderHash blk) [RealPoint blk]  Only a partial path could be constructed from the VolatileDB. The missing predecessor could still be in the ImmutableDB. The list contains the points from oldest to newest.
Note: if the lower bound is exclusive, the block corresponding to it
doesn't have to be part of the VolatileDB, it will result in a
The same invariants hold for the upper bound as for 
computePath ∷ ∀ blk. HasHeader blk ⇒ LookupBlockInfo blk → StreamFrom blk → StreamTo blk → Maybe (Path blk) Source #
Construct a path backwards through the VolatileDB.
We walk backwards through the VolatileDB, constructing a Path
from the
StreamTo
to the StreamFrom
.
If the range is invalid, Nothing
is returned.
See the documentation of Path
.
Reverse path
data ReversePath blk Source #
A reverse path through the VolatileDB starting at a block in the VolatileDB until we reach genesis or leave the VolatileDB.
StoppedAtGenesis  The path stopped at genesis 
StoppedAt (HeaderHash blk) BlockNo  The path stopped at this hash, which is the hash of the predecessor of the last block in the path (that was still stored in the VolatileDB). The block corresponding to the predecessor is not stored in the VolatileDB. Either because it is missing, or because it is old and has been garbage collected. Since block numbers are consecutive, we subtract 1 from the block number of the last block to obtain the block number corresponding to this hash. EBBs share their block number with their predecessor: block: regular block 1  EBB  regular block 2 block number: X  X  X + 1 So when the hash refers to regular block 1, we see that the successor block is an EBB and use its block number without subtracting 1. Edge case: if there are two or more consecutive EBBs, we might predict the wrong block number, but there are no consecutive EBBs in practice, they are one epoch apart. 
(::>)  

∷ ∀ blk. LookupBlockInfo blk  
→ HeaderHash blk  End hash 
→ Maybe (ReversePath blk)  Reverse path from the end point to genesis or the first predecessor not in the VolatileDB. Nothing when the end hash is not in the VolatileDB. 
Lazily compute the ReversePath
that starts (i.e., ends) with the given
HeaderHash
.
Reachability
∷ ∀ blk. (HasHeader blk, GetHeader blk)  
⇒ LookupBlockInfo blk  
→ AnchoredFragment (Header blk)  Chain fragment to connect the point to 
→ RealPoint blk  
→ Maybe (ChainDiff (HeaderFields blk)) 
Try to connect the point P
to the chain fragment by chasing the
predecessors.
When successful, return a ChainDiff
: the number of blocks to roll back
the chain fragment to the intersection point and a fragment anchored at the
intersection point containing the HeaderFields
corresponding to the
blocks needed to connect to P
. The intersection point will be the most
recent intersection point.
Returns Nothing
when P
is not in the VolatileDB or when P
is not
connected to the given chain fragment.
POSTCONDITION: the returned number of blocks to roll back is less than or equal to the length of the given chain fragment.
Note that the number of returned points can be smaller than the number of
blocks to roll back. This means P
is on a fork shorter than the given
chain fragment.
A ChainDiff
is returned iff P
is on the chain fragment. Moreover, when
the number of blocks to roll back is also 0, it must be that P
is the tip
of the chain fragment.
When the suffix of the ChainDiff
is nonempty, P
will be the last point
in the suffix.