Type Members

1.  trait AbstractSequencerPruningStatus extends AnyRef
2.  final case class AggregatedSender(sender: Member, aggregation: AggregationBySender) extends Product with Serializable
3.  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)
4.  final case class BatchWritten(notifies: WriteNotification, latestTimestamp: CantonTimestamp) extends Product with Serializable
5.  sealed trait CommitMode extends AnyRef
6.  class CommunityDatabaseSequencerFactory extends DatabaseSequencerFactory
7.  sealed trait CommunitySequencerConfig extends SequencerConfig
8.  final case class CommunitySequencerReaderConfig(readBatchSize: Int = SequencerReaderConfig.defaultReadBatchSize, checkpointInterval: NonNegativeFiniteDuration = SequencerReaderConfig.defaultCheckpointInterval) extends SequencerReaderConfig with Product with Serializable
9.  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.

10.  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.

11.  class DatabaseSequencer extends BaseSequencer with FlagCloseable
12.  trait DatabaseSequencerConfig extends AnyRef

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

13.  abstract class DatabaseSequencerFactory extends SequencerFactory
14.  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.

15.  class EnterpriseDatabaseSequencerFactory extends DatabaseSequencerFactory with NamedLogging
16.  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.

17.  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.

18.  final case class FreshInFlightAggregation(maxSequencingTimestamp: CantonTimestamp, rule: AggregationRule) extends Product with Serializable

    The metadata for starting a fresh in-flight aggregation

19.  final case class InFlightAggregation extends PrettyPrinting with HasLoggerName with Product with Serializable

    Stores the state of an in-flight aggregation of submission requests.

    Stores the state of an in-flight aggregation of submission requests.

    Since the com.digitalasset.canton.sequencing.protocol.AggregationId computationally identifies the envelope contents, their recipients, and the com.digitalasset.canton.sequencing.protocol.SubmissionRequest.timestampOfSigningKey, we do not need to maintain these data as part of the in-flight tracking. Instead, we can derive them from the submission request that makes the aggregation reach its threshold.

20.  final case class InFlightAggregationUpdate(freshAggregation: Option[FreshInFlightAggregation], aggregatedSenders: Chain[AggregatedSender]) extends Product with Serializable

    Describes an incremental update to the in-flight aggregation state

21.  type InFlightAggregationUpdates = Map[AggregationId, InFlightAggregationUpdate]
22.  type InFlightAggregations = Map[AggregationId, InFlightAggregation]
23.  sealed trait LedgerIdentity extends AnyRef

    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.

24.  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.

25.  final case class OnlineSequencerCheckConfig(onlineCheckInterval: NonNegativeFiniteDuration = config.NonNegativeFiniteDuration.ofSeconds(5L), offlineDuration: NonNegativeFiniteDuration = config.NonNegativeFiniteDuration.ofSeconds(8L)) extends Product with Serializable
26.  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.

27.  class PayloadMissingException extends SequencerWriterException

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

28.  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.

29.  sealed trait PruningError extends AnyRef

    Errors from pruning

30.  sealed trait PruningSupportError extends PruningError
31.  sealed trait ReadSignal extends AnyRef

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

32.  class SendEventGenerator extends AnyRef
33.  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.

34.  trait Sequencer extends SequencerPruning with CloseableHealthQuasiComponent with AtomicHealthElement with HasCloseContext with NamedLogging

    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.

35.  final 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.

36.  trait SequencerConfig extends AnyRef
37.  trait SequencerFactory extends AutoCloseable
38.  final 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.

39.  final case class SequencerInitialState(domainId: DomainId, snapshot: SequencerSnapshot, latestTopologyClientTimestamp: Option[CantonTimestamp], initialTopologyEffectiveTimestamp: Option[CantonTimestamp]) extends Product with Serializable
40.  final case class SequencerMemberStatus(member: Member, registeredAt: CantonTimestamp, lastAcknowledged: Option[CantonTimestamp], enabled: Boolean = true) extends PrettyPrinting with Product with Serializable
41.  class SequencerOfflineException extends SequencerWriterException

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

42.  trait SequencerPruning extends AnyRef

    Sequencer pruning interface.

43.  final case class SequencerPruningStatus(lowerBound: CantonTimestamp, now: CantonTimestamp, members: Seq[SequencerMemberStatus]) extends AbstractSequencerPruningStatus with PrettyPrinting with Product with Serializable

    Pruning status of a Sequencer.

    Pruning status of a Sequencer.

    now

    the current time of the sequencer clock

44.  class SequencerReader extends NamedLogging with FlagCloseable with HasCloseContext
45.  trait SequencerReaderConfig extends AnyRef

    Configuration for the database based sequence reader.

46.  final case class SequencerSnapshot(lastTs: CantonTimestamp, heads: Map[Member, SequencerCounter], status: SequencerPruningStatus, inFlightAggregations: InFlightAggregations, additional: Option[ImplementationSpecificInfo], trafficSnapshots: Map[Member, MemberTrafficSnapshot])(representativeProtocolVersion: RepresentativeProtocolVersion[SequencerSnapshot.type]) extends HasProtocolVersionedWrapper[SequencerSnapshot] with Product with Serializable
47.  class SequencerWriter extends NamedLogging with FlagCloseableAsync with HasCloseContext

    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).
48.  sealed trait SequencerWriterConfig extends AnyRef

    Configuration for the database based sequencer writer

49.  sealed abstract class SequencerWriterException extends RuntimeException

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

50.  class SequencerWriterQueues extends NamedLogging
51.  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.

52.  trait SignatureVerifier extends AnyRef
53.  sealed trait Write extends AnyRef

    A write we want to make to the db

54.  sealed trait WriteNotification extends AnyRef

    Who gets notified that a event has been written

55.  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.