Type Members

1.  case class BlockEvents(height: Long, events: Seq[Traced[LedgerBlockEvent]]) extends Product with Serializable
2.  class BlockSequencerStateManager extends FlagCloseableAsync with NamedLogging

   State manager for operating a sequencer using Blockchain based infrastructure (such as fabric or ethereum)

3.  class BlockUpdateGenerator extends NamedLogging

   Exposes functions that take the deserialized contents of a block from a blockchain integration and computes the new com.digitalasset.canton.domain.block.BlockUpdates.

   Exposes functions that take the deserialized contents of a block from a blockchain integration and computes the new com.digitalasset.canton.domain.block.BlockUpdates. Used by Ethereum and Fabric integrations.

   In particular, these functions are responsible for the final timestamp assignment of a given submission request. The timestamp assignment works as follows: 1. an initial timestamp is assigned to the submission request by the sequencer that writes it to the ledger 2. each sequencer that reads the block potentially adapts the previously assigned timestamp deterministically via ensureStrictlyIncreasingTimestamp 3. this timestamp is used to compute the com.digitalasset.canton.domain.block.BlockUpdates

   Reasoning: Step 1 is done so that every sequencer sees the same timestamp for a given event. Step 2 is needed because different sequencers may assign the same timestamps to different events or may not assign strictly increasing timestamps due to clock skews.

   Invariants: For step 2, we assume that every sequencer observes the same stream of events from the underlying ledger (and especially that events are always read in the same order).

4.  sealed trait BlockUpdates extends Product with Serializable

   A series of changes from processing the chunks of updates within a block.

5.  case class ChunkUpdate(newMembers: Map[Member, CantonTimestamp] = Map.empty, membersDisabled: Seq[Member] = Seq.empty, acknowledgements: Map[Member, CantonTimestamp] = Map.empty, invalidAcknowledgements: Seq[(Member, CantonTimestamp)] = Seq.empty, signedEvents: Seq[NonEmpty[Map[Member, OrdinarySerializedEvent]]] = Seq.empty, pruningRequests: Seq[Traced[CantonTimestamp]] = Seq.empty, lastTopologyClientTimestamp: Option[CantonTimestamp], state: EphemeralState) extends Product with Serializable

   Changes from processing a consecutive part of updates within a block from the blockchain.

   Changes from processing a consecutive part of updates within a block from the blockchain. We expect all values to be consistent with one another:

   • new members must exist in the registered members
   • the provided timestamps must be at or after the latest sequencer timestamp of the previous chunk or block
   • members receiving events must be registered
   • timestamps of events must not after the latest sequencer timestamp of the previous chunk or block
   • counter values for each member should be continuous

   newMembers

   members that were added along with the timestamp that they are considered registered from

   acknowledgements

   The highest valid acknowledged timestamp for each member in the block

   invalidAcknowledgements

   All invalid acknowledgement timestamps in the block for each member

   lastTopologyClientTimestamp

   The highest timestamp of an event in events addressed to the sequencer's topology client, if any

   state

   updated ephemeral state to be used for processing subsequent chunks

6.  case class CompleteBlockUpdate(block: BlockInfo) extends BlockUpdates with Product with Serializable

   Signals that all updates in a block have been delivered as chunks.

   Signals that all updates in a block have been delivered as chunks. The com.digitalasset.canton.domain.block.data.BlockInfo must be consistent with the updates in all earlier ChunkUpdates. In particular: - com.digitalasset.canton.domain.block.data.BlockInfo.lastTs must be at least the one from the last chunk or previous block - com.digitalasset.canton.domain.block.data.BlockInfo.latestTopologyClientTimestamp must be at least the one from the last chunk or previous block. - com.digitalasset.canton.domain.block.data.BlockInfo.height must be exactly one higher than the previous block The consistency conditions are checked in handleUpdate

7.  sealed trait LedgerBlockEvent extends Product with Serializable

   Trait that generalizes over the kind of events that could be observed in a blockchain integration.

   Trait that generalizes over the kind of events that could be observed in a blockchain integration.

   Used by Ethereum and Fabric.

8.  case class PartialBlockUpdate(chunk: ChunkUpdate, continuation: Future[BlockUpdates]) extends BlockUpdates with Product with Serializable

   A chunk of updates within a block.

   A chunk of updates within a block. The updates can be delivered to com.digitalasset.canton.sequencing.client.SequencerClients immediately, before fully processing the block.

   The next partial block update may depend on the events in the current chunk, e.g., by the topology processor processing them via its sequencer client subscription. For this reason, the next partial block update is wrapped in its own future, which can sync the topology updates via the topology client.

   continuation

   Computes the remainder of updates in a given block

9.  class SequencerUnexpectedStateChange extends RuntimeException

   Thrown if the ephemeral state does not match what is expected in the persisted store.

   Thrown if the ephemeral state does not match what is expected in the persisted store. This is not expected to be able to occur, but if it does likely means that the ephemeral state is inconsistent with the persisted state. The sequencer should be restarted and logs verified to ensure that the persisted state is correct.