Documentation

Followers are represented here as a relation.

Producer keeps track of consumer chain. The only information for a producer to know is

• followerPoint: (some) intersection point of consumer's chain and producer's chain;
• followerNext: information what to do on next instruction: either roll forward from the intersection point or roll back to it.

The second piece of information is needed to distinguish the following two cases:

• consumer chain is a subchain of the producer chain
• it is a fork.

Since consumer is following the producer chain, the producer has this information at its end. If producer updates its chain to use another fork it may happen that the follower pointer is not on the new chain. In this case the producer will set RollBackTo and find intersection of the two chains for followerPoint. And upon consumer's request will replay with MsgRollBackward followerPoint. After sending this message, the producer assumes that the the consumer is following the protocol (i.e. will rollback its chain) and will reset the followerNext field to FollowerForwardFrom. The second case: when the followerNext is FollowerForwardFrom, then when sending next instruction the producer will either:

• take the next block (or header) on its chain imediatelly folowing the followerPoint, updtate followerPoint to the point of the new value and send MsgRollForward with the new block (or header).
• if there is no block, which means that the consumer side and producer side are synchornized, the producer will send MsgAwaitResponse and will wait until its chain is updated: either by a fork or by a new block.

In this implementation a map from FollowerId to FollowerState is shared between all producers running on a single node; hence the unique identifier FollowerId for each follower: this is an implementation detail.

Initialise ChainProducerState with a given Chain and empty list of followers.

Get the recorded state of a chain consumer. The FollowerId is assumed to exist.

Return True when a follower with the given FollowerId exists.

Extract Chain from ChainProducerState.

Add a new follower with the given intersection point and return the new FollowerId.

Delete an existing follower. The FollowerId is assumed to exist.

Change the intersection point of a follower. This also puts it into the FollowerBackTo state.

Switch chains and update followers; if a follower point falls out of the chain, replace it with the intersection of both chains and put it in the FollowerBackTo state, otherwise preserve follower state.

What a follower needs to do next. Should they move on to the next block or do they need to roll back to a previous point on their chain. It also updates the producer's state assuming that the follower follows its instruction.

Add a block to the chain. It does not require any follower's state changes.

Rollback producer chain. It requires to update follower states, since some followerPoints may not be on the new chain; in this case find intersection of the two chains and set followerNext to FollowerBackTo.

Convenient function which combines both addBlock and rollback.

Apply a list of ChainUpdates.