An AnchoredFragment is a fragment of a chain that is anchored somewhere in that chain. The Anchor corresponds to the block immediately before the first, leftmost block in the fragment. The block corresponding to the anchor is not present in the fragment. The anchor can be thought of as a left exclusive bound.

For example, the following fragment is anchored at a and contains b1, b2, and b3, which is the head of the fragment.

a ] b1 >: b2 >: b3

The fact that it is an exclusive bound is particularly convenient when dealing with Genesis. Genesis is the start of the chain, but not an actual block, so we cannot use it an inclusive bound. However, there is an Anchor that refers to Genesis (AnchorGenesis), which can be used as the anchor, acting as an exclusive bound.

An AnchoredFragment anchored at Genesis can thus be converted to a Chain (fromAnchoredFragment), containing all blocks starting from Genesis.

Without an anchor point, an empty fragment wouldn't give us much more information: is it empty because the whole chain is empty? Or, did we just get an empty fragment that was split off from some later part of the chain?

Generalisation of a Sequence with elements of type b with a custom measure v and an anchor a.

This type is strict in the elements, but not strict in the spine.

For example, an AnchoredSeq can represent a fragment of a chain containing blocks that is anchored at a certain point. It can also represent a history of ledger states with the anchor being the "immutable" ledger state.

NOTE: there might be multiple elements with the same measure, e.g., multiple blocks with the same WithOrigin SlotNo. That is why functions operating on an AnchoredSeq often take a predicate in addition to a measure. At most one element should satisfy that predicate, e.g., the block must have a certain hash. The behaviour is undefined when multiple elements satisfy the predicate.

Return the Point corresponding to the anchor.

Return the BlocKno corresponding to the anchor.

Anchor of an AnchoredFragment

Construct anchor from a block

In other words, this would be the block immediately before the other blocks in the fragment.

Construct an anchor from a point

In this case, we must also be given the BlockNo. This only makes sense for points that aren't genesis.

Compute which Point this anchor corresponds to

Extract the SlotNo from the anchor

Extract the BlockNo from the anchor

NOTE: When the Anchor is AnchorGenesis, this returns Origin. It does not return genesisBlockNo, which is badly named, and is instead the block number of the first block on the chain (i.e., genesisPoint and genesisBlockNo don't go hand in hand!)

Extract the hash from the anchor

Returns GenesisHash if the anchor is AnchorGenesis.

Does this anchor represent genesis (i.e., empty chain)?

Translate Anchor to Tip

Right now this is in fact an isomorphism, but these two types are logically independent.

The equivalent of castPoint for Anchor

\( O(n) \).

\( O(1) \).

Abstract over the shape of blocks (or indeed just block headers)

A point on the chain is identified by its Slot and HeaderHash.

The Slot tells us where to look and the HeaderHash either simply serves as a check, or in some contexts it disambiguates blocks from different forks that were in the same slot.

It's a newtype rather than a type synonym, because using a type synonym would lead to ambiguity, since HeaderHash is a non-injective type family.

\( O(1) \). When the fragment is empty, the anchor point is returned.

\( O(1) \). The anchor corresponding to the most recently added element (i.e., the anchor that would be needed for a sequence starting after this). When the anchored sequence is empty, the anchor is returned.

\( O(1) \). When the fragment is empty, the slot of the anchor point is returned, which may be origin (no slot).

\( O(1) \). When the fragment is empty, the hash of the anchor point is returned.

\( O(1) \). When the fragment is empty, the block number of the anchor point is returned.

\( O(1) \). When the sequence is empty, return the anchor, otherwise the most recently added element.

\( O(1) \). When the sequence is empty, return the anchor, otherwise the leftmost element.

\( O(1) \). When the fragment is empty, the anchor point is returned.

\( O(1) \). When the fragment is empty, the slot of the anchor point is returned, which may be the origin and therefore have no slot.

\( O(n) \). Return the elements in the AnchoredSeq in newest-to-oldest order.

\( O(n) \). Return the elements in the AnchoredSeq in oldest-to-newest order.

\( O(n) \). Make an AnchoredSeq from a list of elements in newest-to-oldest order. The last element in the list will be the one after the given anchor.

\( O(n) \). Make an AnchoredSeq from a list of elements in oldest-to-newest order. The first element in the list will be the one after the given anchor.

\( O(\log(\min(i,n-i)) \). Split the AnchoredSeq at a given position.

POSTCONDITION: (before, after) = splitAt i s, then:

anchor      before == anchor s
headAnchor  before == anchor after
headAnchor  after  == headAnchor s
join before after  == Just s

\( O(\log(\min(i,n-i)) \). Drop the newest n elements from the AnchoredSeq. The anchor does not change.

\( O(\log(\min(i,n-i)) \). Take the oldest n elements from the AnchoredSeq. The anchor does not change.

\( O(n) \). Drop the newest elements that satisfy the predicate, keeping the remainder. The anchor does not change.

\( O(n) \). Take the oldest elements that satisfy the predicate. The anchor does not change.

\( O(1) \). Return the number of elements. The anchor is not counted.

\( O(1) \). The anchor is not counted.

A representation of two actions to update a chain: add a block or roll back to a previous point.

The type parameter a is there to allow a Functor instance. Typically, it will be instantiated with block itself.

\( O(1) \). Add a block to the right of the anchored fragment.

Synonym for :>.

\( O(\log(\min(i,n-i)) \). If the Point is within the bounds of the AnchoredFragment (see withinFragmentBounds), roll back the anchored fragment such that its head is the given point. In case the given point was the anchor point, the returned anchored fragment will be empty.

In other words, remove blocks from the end of the AnchoredFragment until the given Point is the head. If the given Point is not within the bounds of the AnchoredFragment, return Nothing.

\( O(\log(\min(i,n-i)) \). Does the fragment contain a block with the given point? The anchor point is ignored.

\( O(\log(\min(i,n-i)) \). Is the point within the fragment bounds? Either the point is the anchor point, or it corresponds to a block "on" the fragment.

\( O(p \log(\min(i,n-i)) \). Find the first Point in the list of points that is within the fragment bounds. Return Nothing if none of them are.

\( O(\log(\min(i,n-i)) \). Find the block after the given point. If the given point is the anchor point, then the first block is returned (if there is one).

\( O(o \log(\min(i,n-i))) \). Select a bunch of Points based on offsets from the head of the anchored fragment. This is used in the chain consumer protocol as part of finding the intersection between a local and remote chain.

The list of offsets must be increasing monotonically.

The typical pattern is to use a selection of offsets covering the last K blocks, biased towards more recent blocks. For example:

selectPoints (0 : [ fib n | n <- [1 .. 17] ])

Only for offsets within the bounds of the anchored fragment will there be points in the returned list.

Note: offset n, where n equals the length of the anchored fragment, corresponds to the anchor point. When the fragment is empty, offset 0 will thus correspond to the anchor point.

\( O(\max(n_1, n_2)) \). Check whether the first anchored sequence is a prefix of the second. Comparisons are done based on the Eq instances.

The two AnchoredSeqs must have the same anchor, otherwise the first cannot be a prefix of the second.

\( O(\log(\min(i,n-i)) \). Split the AnchoredFragment after the given Point. Return Nothing if given Point is not within the fragment bounds (withinFragmentBounds).

The given Point may be the anchor point of the fragment, in which case the empty fragment with the given anchor point and the original fragment are returned.

POSTCONDITION: when Just (before, after) = splitAfterPoint f pt, then:

• anchorPoint before == anchorPoint f

• headPoint   before == pt

• anchorPoint after  == pt

• headPoint   after  == headPoint f

• join before after  == Just f

\( O(\log(\min(i,n-i)) \). Split the AnchoredFragment at the given slot.

POSTCONDITION: when (before, after) = splitAtSlot s f, then:

• anchorPoint before == anchorPoint f

• headPoint   before == anchorPoint after

• headPoint   after  == headPoint f

• join before after  == Just f

• toOldestFirst before == filter ((< s) . blockSlot) (toOldestFirst f)

• toOldestFirst after == filter ((s <=) . blockSlot) (toOldestFirst f)

\( O(\log(\min(i,n-i)) \). Split the AnchoredFragment before the given Point. Return Nothing if given Point is not on the fragment (pointOnFragment).

This means that Nothing is returned if the given Point is the anchor point of the fragment.

POSTCONDITION: joining (join) the two fragments gives back the original fragment.

POSTCONDITION: the last block (oldest) on the second fragment corresponds to the given point.

Select a slice of an anchored fragment between two points, inclusive.

Both points must exist on the chain, in order, or the result is Nothing.

\( O(\log(\min(n_1, n_2))) \). Join two anchored fragments if the anchor of the second fragment is the head (newest block) of the first fragment.

If the first fragment is empty, it can be joined if its anchor is the same as the second fragment's anchor.

The returned fragment will have the same anchor as the first fragment.

\( O(n_2 \log(n_1)) \). Look for the most recent intersection of two AnchoredFragments c1 and c2.

The fragments need not have the same anchor point.

If they intersect, i.e., share a common Point (possibly the anchor point), then return a tuple of:

• p1: the prefix of the first fragment
• p2: the prefix of the second fragment
• s1: the suffix of the first fragment
• s2: the suffix of the second fragment

p1 and p2 will have the same head (possibly an anchor point), namely the intersection point i. The original chain c1 can be obtained by putting s1 after p1, similarly for c2: by putting s2 after p2:

Just c1 = join p1 s1
Just c2 = join p2 s2

Take for example the following two fragments that share blocks 4 and 5. The two fragments are fragments of the same chain, but don't contain all blocks of the original chain. The anchor points of the fragments are indicated with an asterisk (*). The -A and -B suffixes denote that blocks are part of a fork of the chain.

    ┆ 1*┆
    ├───┤
    │ 2 │     ┆ 2*┆
    ├───┤     ├───┤
    │ 4 │     │ 4 │
    ├───┤     ├───┤
    │ 5 │     │ 5 │
────┼───┼─────┼───┼───
    │ 6A│     │ 6B│
    └───┘     ├───┤
              │ 8B│
              └───┘
      c1        c2

The intersection of c1 and c2 is block 5 (the last Point the two fragments have in common) and we return the following fragments:

    ┆ 1*┆
    ├───┤
    │ 2 │     ┆ 2*┆
    ├───┤     ├───┤
    │ 4 │     │ 4 │
    ├───┤     ├───┤
    │ 5 │     │ 5 │      ┆ 5*┆     ┆ 5*┆
────┴───┴─────┴───┴──────┼───┼─────┼───┼──
                         │ 6A│     │ 6B│
                         └───┘     ├───┤
                                   │ 8B│
                                   └───┘
Just (p1,       p2,        s1,       s2)

The intersection point will be the anchor point of fragments s1 and s2. Fragment p1 will have the same anchor as c1 and p2 will have the same anchor as c2.

Note that an empty fragment can still intersect another fragment, as its anchor point can still intersect the other fragment. In that case the respective prefix and suffix are both equal to original empty fragment. Additionally, two empty fragments intersect if their anchor points are equal, in which case all prefixes and suffixes are equal to the empty fragment with the anchor point in question.

\( O(n_2 \log(n_1)) \). Look for the most recent intersection point of two AnchoredFragments

The fragments need not have the same anchor point.

Reusing the example in the docstring of intersect: this function will return the anchor point 5*.

\( O(n) \). Maps over the chain's blocks. This is not allowed to change the block Points, or it would create an invalid chain. The anchorPoint is not affected.

Take the n newest elements from the anchored sequence.

WARNING: this may change the anchor

When the anchored sequence contains fewer than n elements, the anchored sequence will be returned unmodified.

\( O(n) \). Variation on filterWithStop without a stop condition.

\( O(n + r * \log(\min(i,n-i)) \) where r is the number of consecutive ranges of elements to be included in the result.

Filter out elements that don't match the predicate.

As filtering removes elements the result is a sequence of disconnected sequences. The sequences are in the original order and are of maximum size.

As soon as the stop condition is true, the filtering stops and the remaining sequence (starting with the first element for which the stop condition is true) is the final sequence in the returned list.

The stop condition wins from the filtering predicate: if the stop condition is true for an element, but the filter predicate not, then the element still ends up in final sequence.

For example, given the sequence containing [0: 1, 2, 3, 4, 5, 6] where the anchor is separated from the elements by ::

filter         odd        -> [[0: 1], [2: 3], [4: 5]]
filterWithStop odd (>= 4) -> [[0: 1], [2: 3], [3: 4, 5, 6]]

\( O(n) \). Specification of pointOnFragment.

Use pointOnFragment, as it should be faster.

This function is used to verify whether pointOnFragment behaves as expected.

\( O(o * n) \). Specification of selectPoints.

Use selectPoints, as it should be faster.

This function is used to verify whether selectPoints behaves as expected.

\( O(n) \). Naive reference implementation of filterWithStop.

While the asymptotic complexity of this function is better than that of filterWithStop, the allocation cost is high. This function deconstructs and reconstructs the anchored sequence (until the stop condition is reached), even when no elements are removed.