Type Members

1.  abstract class BaseSequencer extends Sequencer with NamedLogging with Spanning

   Provides additional functionality that is common between sequencer implementations:

   Provides additional functionality that is common between sequencer implementations:

   • auto registers unknown recipients addressed in envelopes from the domain topology manager (avoids explicit registration from the domain node -> sequencer which will be useful when separate processes)
2.  case class BatchWritten(notifies: WriteNotification, latestTimestamp: CantonTimestamp) extends Product with Serializable
3.  type BlockHeight = BigInteger
4.  sealed trait CommitMode extends AnyRef
5.  sealed trait CommunitySequencerConfig extends SequencerConfig
6.  case class CommunitySequencerReaderConfig(readBatchSize: Int = SequencerReaderConfig.defaultReadBatchSize, checkpointInterval: NonNegativeFiniteDuration = SequencerReaderConfig.defaultCheckpointInterval) extends SequencerReaderConfig with Product with Serializable
7.  class ConflictingPayloadIdException extends SequencerWriterException

   We intentionally use an unsafe storage method for writing payloads to take advantage of a full connection pool for performance.

   We intentionally use an unsafe storage method for writing payloads to take advantage of a full connection pool for performance. However this means if a HA Sequencer Writer has lost its instance lock it may still attempt to write payloads while another Sequencer Writer is active with the same instance index. As we use this instance index to generate an (almost) conflict free payload id, in this circumstance there is a slim chance that we may attempt to write conflicting payloads with the same id. If we were using a simple idempotent write approach this could result in the active sequencer writing an event with a payload from the offline writer process (and not the payload it is expecting). This would be a terrible and difficult to diagnose corruption issue.

   If this exception is raised we currently just halt the writer and run crash recovery. This is slightly suboptimal as in the above scenario we may crash the active writer (if they were second to write a conflicting payload id). However this will be safe. We could optimise this by checking the active lock status and only halting if this is found to be false.

8.  class CounterCheckpointInconsistentException extends RuntimeException

   We throw this if a store.SaveCounterCheckpointError.CounterCheckpointInconsistent error is returned when saving a new member counter checkpoint.

   We throw this if a store.SaveCounterCheckpointError.CounterCheckpointInconsistent error is returned when saving a new member counter checkpoint. This is exceptionally concerning as may suggest that we are streaming events with inconsistent counters. Should only be caused by a bug or the datastore being corrupted.

9.  class DatabaseSequencer extends BaseSequencer with FlagCloseable
10.  trait DatabaseSequencerConfig extends AnyRef

    Unsealed trait so the database sequencer config can be reused between community and enterprise

11.  class DirectSequencerClientTransport extends SequencerClientTransport with NamedLogging

    This transport is meant to be used to create a sequencer client that connects directly to an in-process sequencer.

    This transport is meant to be used to create a sequencer client that connects directly to an in-process sequencer. Needed for cases when the sequencer node itself needs to listen to specific events such as identity events.

12.  final case class EthereumAccount(address: String) extends LedgerIdentity with Product with Serializable

    The address of an Ethereum account is derived by taking the last 20 bytes of the Keccak-256 hash of the public key and adding 0x to the beginning.

    The address of an Ethereum account is derived by taking the last 20 bytes of the Keccak-256 hash of the public key and adding 0x to the beginning. See, e.g., [here](https://ethereum.org/en/developers/docs/accounts/#account-creation) as a reference.

13.  trait EventSignaller extends AutoCloseable

    Component to signal to a SequencerReader that more events may be available to read so should attempt fetching events from its store.

14.  sealed trait LedgerIdentity extends HasProtoV0[admin.v0.LedgerIdentity]

    Trait for identities on ledgers that Canton integrates with.

    Trait for identities on ledgers that Canton integrates with. For example, a ledger identity can be an Ethereum account or a Fabric identity.

15.  class LocalSequencerStateEventSignaller extends EventSignaller with FlagCloseableAsync with NamedLogging

    If all Sequencer writes are occurring locally we pipe write notifications to read subscriptions allowing the SequencerReader to immediately read from the backing store rather than polling.

    If all Sequencer writes are occurring locally we pipe write notifications to read subscriptions allowing the SequencerReader to immediately read from the backing store rather than polling.

    An important caveat is that we only supply signals when a write for a member occurs. If there are no writes from starting the process the member will never receive a read signal. The SequencerReader is responsible for performing at least one initial read from the store to ensure that all prior events are served as required.

    Not suitable or at least very sub-optimal for a horizontally scaled sequencer setup where a reader will not have visibility of all writes locally.

16.  case class OnlineSequencerCheckConfig(onlineCheckInterval: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5L), offlineDuration: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(8L)) extends Product with Serializable
17.  type ParsedBlockContents = EthereumBlockContents[Traced[EthereumBlockEvent]]
18.  class PartitionedTimestampGenerator extends AnyRef

    To generate unique timestamps between many nodes without coordination we partition available timestamps by the node index within a range of the total number of nodes.

19.  class PayloadMissingException extends SequencerWriterException

    A payload that we should have just stored now seems to be missing.

20.  class PollingEventSignaller extends EventSignaller with NamedLogging

    Ignore local writes and simply trigger reads periodically based on a static polling interval.

    Ignore local writes and simply trigger reads periodically based on a static polling interval. Suitable for horizontally scaled sequencers where the local process will not have in-process visibility of all writes.

21.  sealed trait PruningError extends AnyRef

    Errors from pruning

22.  sealed trait ReadSignal extends AnyRef

    Signal that a reader should attempt to read the latest events as some may have been written

23.  class SendEventGenerator extends AnyRef
24.  sealed trait SequencedWrite extends HasTraceContext

    A write that we've assigned a timestamp to.

    A write that we've assigned a timestamp to. We drag these over the same clock so we can ensure earlier items have lower timestamps and later items have higher timestamps. This is very helpful, essential you may say, for correctly setting the watermark while ensuring an event with an earlier timestamp will not be written.

25.  trait Sequencer extends FlagCloseable with HasCloseContext

    Interface for sequencer operations.

    Interface for sequencer operations. The default DatabaseSequencer implementation is backed by a database run by a single operator. Other implementations support operating a Sequencer on top of third party ledgers or other infrastructure.

26.  case class SequencerClients(members: Set[Member] = Set.empty) extends Product with Serializable

    Structure housing both members and instances of those members.

    Structure housing both members and instances of those members. Used to list clients that have been or need to be disabled.

27.  trait SequencerConfig extends AnyRef
28.  trait SequencerFactory extends AnyRef
29.  case class SequencerHealthConfig(backendCheckPeriod: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5)) extends Product with Serializable

    Health check related sequencer config

    Health check related sequencer config

    backendCheckPeriod

    interval with which the sequencer will poll the health of its backend connection or state.

30.  case class SequencerMemberStatus(member: Member, registeredAt: CantonTimestamp, lastAcknowledged: Option[CantonTimestamp], enabled: Boolean = true) extends HasProtoV0[admin.v0.SequencerMemberStatus] with Product with Serializable
31.  class SequencerOfflineException extends SequencerWriterException

    Throw as an error in the akka stream when we discover that our currently running sequencer writer has been marked as offline.

32.  class SequencerPeriodicHealthCheck extends NamedLogging

    Utility for periodically calling the sequencer's health check.

    Utility for periodically calling the sequencer's health check. This is done because when the sequencer computes the health status, it will notify listeners in case the health status has changed.

33.  case class SequencerPruningStatus(lowerBound: CantonTimestamp, now: CantonTimestamp, members: Seq[SequencerMemberStatus]) extends HasProtoV0[admin.v0.SequencerPruningStatus] with Product with Serializable

    Pruning status of a Sequencer.

    Pruning status of a Sequencer.

    lowerBound

    the earliest timestamp that can be read

    now

    the current time of the sequencer clock

    members

    details of registered members

34.  class SequencerReader extends NamedLogging with FlagCloseable
35.  trait SequencerReaderConfig extends AnyRef

    Configuration for the database based sequence reader.

36.  case class SequencerSnapshot(lastTs: CantonTimestamp, heads: Map[Member, SequencerCounter], status: SequencerPruningStatus, additional: Option[ImplementationSpecificInfo]) extends HasProtoV0[admin.v0.SequencerSnapshot] with HasVersionedWrapper[VersionedMessage[SequencerSnapshot]] with Product with Serializable
37.  class SequencerWriter extends NamedLogging with FlagCloseableAsync

    The Writer component is in practice a little state machine that will run crash recovery on startup then create a running SequencerWriterSource.

    The Writer component is in practice a little state machine that will run crash recovery on startup then create a running SequencerWriterSource. If this materialized Sequencer flow then crashes with an exception that can be recovered by running crash recovery it will then go through this process and attempt to restart the flow.

    Callers must call start to start the writer and will likely have to wait for this completing before accepting calls for the sequencer to direct at send. Note that the crash recovery steps may take a long duration to run:

    • we delete invalid events previously written by the sequencer and then attempt to insert a new online watermark, and these database queries may simply take a long time to run.
    • the SequencerWriter will wait until our clock has reached the new online watermark timestamp before starting the writer to ensure that no events before this timestamp are written. If this online watermark is significantly ahead of the current clock value it will just wait until this is reached. In practice assuming all sequencers in the local topology are kept in sync through NTP or similar, this duration should be very small (<1s).
38.  sealed trait SequencerWriterConfig extends AnyRef

    Configuration for the database based sequencer writer

39.  sealed abstract class SequencerWriterException extends RuntimeException

    Base class for exceptions intentionally thrown during Akka stream to flag errors

40.  class SequencerWriterQueues extends NamedLogging
41.  trait SequencerWriterStoreFactory extends AutoCloseable

    Create instances for a store.SequencerWriterStore and a predicate to know whether we can recreate a sequencer writer on failures encountered potentially during storage.

    Create instances for a store.SequencerWriterStore and a predicate to know whether we can recreate a sequencer writer on failures encountered potentially during storage. Implements AutoClosable so implementations can use lifecycle.FlagCloseable to short circuit retry attempts.

42.  type UnparsedBlockContents = EthereumBlockContents[BaseEventResponse]

    Unparsed in this context meaning the raw web3j codegen java instances (which to be fair have already been extracted from the raw transaction event log).

43.  sealed trait Write extends AnyRef

    A write we want to make to the db

44.  sealed trait WriteNotification extends AnyRef

    Who gets notified that a event has been written

45.  trait WriterStartupError extends AnyRef

    Errors that can occur while starting the SequencerWriter.

    Errors that can occur while starting the SequencerWriter. In the HA Sequencer Writer it is possible due to racy assignment of writer locks that the startup may fail. This is by design and starting the writer can simply be retried. However other errors such as discovering incorrect configuration or a unexpected commit mode will not be recoverable and the writer should propagate the failure.