Type Members

1.  trait ApplicationHandler[-Box[+_ <: Envelope[_]], -Env <: Envelope[_]] extends (BoxedEnvelope[Box, Env]) => HandlerResult

   An application handler processes boxed envelopes and returns a HandlerResult

2.  final case class AsyncResult(unwrap: FutureUnlessShutdown[Unit]) extends Product with Serializable

   The asynchronous part of processing an event (or of a stage of its processing).

   The asynchronous part of processing an event (or of a stage of its processing).

   Annotations

   @DoNotDiscardLikeFuture()

3.  type BoxedEnvelope[+Box[+_ <: Envelope[_]], +Env <: Envelope[_]] = Box[Env]

   It is convenient to consider the envelopes and all the structure around the envelopes (the box).

   It is convenient to consider the envelopes and all the structure around the envelopes (the box). EnvelopeBox defines type class operations to manipulate

4.  class DelayLogger extends AnyRef

   Wrapper for a sequencer subscription event handler that will log warnings if the timestamps of received messages appear significantly behind this consumer's clock.

5.  trait EnvelopeBox[Box[+_ <: Envelope[_]]] extends AnyRef

   Type class to manipulate envelopes inside their box.

   Type class to manipulate envelopes inside their box. Specializes cats.Traverse to protocol.Envelope arguments.

6.  type EnvelopeHandler = ApplicationHandler[NoEnvelopeBox, DefaultOpenEnvelope]
7.  final case class GrpcSequencerConnection(endpoints: NonEmpty[Seq[Endpoint]], transportSecurity: Boolean, customTrustCertificates: Option[ByteString], sequencerAlias: SequencerAlias) extends SequencerConnection with Product with Serializable
8.  type HandlerResult = FutureUnlessShutdown[AsyncResult]

   A handler processes an event synchronously in the scala.concurrent.Future and returns an AsyncResult that may be computed asynchronously by the contained future.

   A handler processes an event synchronously in the scala.concurrent.Future and returns an AsyncResult that may be computed asynchronously by the contained future. Asynchronous processing may run concurrently with later events' synchronous processing and with asynchronous processing of other events.

9.  type NoEnvelopeBox[+E <: Envelope[_]] = Traced[Seq[E]]
10.  type OrdinaryApplicationHandler[-E <: Envelope[_]] = ApplicationHandler[OrdinaryEnvelopeBox, E]
11.  type OrdinaryEnvelopeBox[+E <: Envelope[_]] = Traced[Seq[OrdinarySequencedEvent[E]]]

    Default box for signed batches of events The outer Traced contains a trace context for the entire batch.

12.  type OrdinaryProtocolEvent = OrdinarySequencedEvent[DefaultOpenEnvelope]

    Default type for deserialized events.

    Default type for deserialized events. Includes a signature and a trace context.

13.  type OrdinarySerializedEvent = OrdinarySequencedEvent[ClosedEnvelope]

    Default type for serialized events.

    Default type for serialized events. Contains trace context and signature.

14.  type OrdinarySerializedEventOrError = Either[SequencedEventError, OrdinarySerializedEvent]
15.  type PossiblyIgnoredApplicationHandler[-E <: Envelope[_]] = ApplicationHandler[PossiblyIgnoredEnvelopeBox, E]
16.  type PossiblyIgnoredEnvelopeBox[+E <: Envelope[_]] = Traced[Seq[PossiblyIgnoredSequencedEvent[E]]]

    Default box for PossiblyIgnoredProtocolEvents.

    Default box for PossiblyIgnoredProtocolEvents. The outer Traced contains a trace context for the entire batch.

17.  type PossiblyIgnoredProtocolEvent = PossiblyIgnoredSequencedEvent[DefaultOpenEnvelope]

    Deserialized event with optional payload.

18.  type PossiblyIgnoredSerializedEvent = PossiblyIgnoredSequencedEvent[ClosedEnvelope]
19.  type RawProtocolEvent = SequencedEvent[DefaultOpenEnvelope]

    Default type for deserialized events.

    Default type for deserialized events. The term "raw" indicates that the trace context is missing. Try to use TracedProtocolEvent instead.

20.  type RawSignedContentEnvelopeBox[+Env <: Envelope[_]] = SignedContent[SequencedEvent[Env]]

    Just a signature around the com.digitalasset.canton.sequencing.protocol.SequencedEvent The term "raw" indicates that the trace context is missing.

    Just a signature around the com.digitalasset.canton.sequencing.protocol.SequencedEvent The term "raw" indicates that the trace context is missing. Try to use the box OrdinarySerializedEvent instead.

21.  sealed trait ResubscriptionStart extends SubscriptionStart

    The subscription is a resubscription.

    The subscription is a resubscription. The application handler may have previously been called with an event.

22.  class SequencedEventMonotonicityChecker extends NamedLogging

    Checks that the sequenced events' sequencer counters are a gap-free increasing sequencing starting at firstSequencerCounter and their timestamps increase strictly monotonically.

    Checks that the sequenced events' sequencer counters are a gap-free increasing sequencing starting at firstSequencerCounter and their timestamps increase strictly monotonically. When a violation is detected, an error is logged and the processing is aborted.

    This is normally ensured by the com.digitalasset.canton.sequencing.client.SequencedEventValidator for individual sequencer subscriptions. However, due to aggregating multiple subscriptions from several sequencers up to a threshold, the stream of events emitted by the aggregation may violate monotonicity. This additional monotonicity check ensures that we catch such violations before we pass the events downstream.

23.  class SequencerAggregator extends NamedLogging with FlagCloseable
24.  class SequencerAggregatorPekko extends NamedLogging

    Aggregates sequenced events from a dynamically configurable set of com.digitalasset.canton.sequencing.client.SequencerSubscriptionPekkos until a configurable threshold is reached.

25.  class SequencerClientRecorder extends FlagCloseable with NamedLogging

    Record interactions that the Sequencer client has with its domain.

    Record interactions that the Sequencer client has with its domain. If enabled will record sends to the Sequencer and events received from the Sequencer subscription. Callers must call start with a path for recording before recording sequencer interactions.

26.  sealed trait SequencerConnection extends PrettyPrinting

    Our com.digitalasset.canton.config.SequencerConnectionConfig provides a flexible structure for configuring how the domain and its members talk to a sequencer.

    Our com.digitalasset.canton.config.SequencerConnectionConfig provides a flexible structure for configuring how the domain and its members talk to a sequencer. It however leaves much information intentionally optional so it can be inferred at runtime based on information that may only be available at the point of creating a sequencer connection (for instance defaulting to domain connection information that a user has provided in an admin command). At this point these structures can then be constructed which contain all the mandatory details that sequencer clients need to actually connect.

27.  final case class SequencerConnections extends HasVersionedWrapper[SequencerConnections] with PrettyPrinting with Product with Serializable
28.  type SerializedEventHandler[Err] = (OrdinarySerializedEvent) => Future[Either[Err, Unit]]

    Default type for handlers on serialized events with error reporting

29.  type SerializedEventOrErrorHandler[Err] = (OrdinarySerializedEventOrError) => Future[Either[Err, Unit]]
30.  sealed trait SubscriptionStart extends Product with Serializable with PrettyPrinting

    Information passed by the com.digitalasset.canton.sequencing.client.SequencerClient to the ApplicationHandler where the subscription (= processing of events) starts.

    Information passed by the com.digitalasset.canton.sequencing.client.SequencerClient to the ApplicationHandler where the subscription (= processing of events) starts. The ApplicationHandler can then initialize itself appropriately.

31.  type TracedProtocolEvent = Traced[RawProtocolEvent]

    Deserialized event with a trace context.

    Deserialized event with a trace context. Use this when you are really sure that a signature will never be needed.

32.  type UnsignedApplicationHandler[-E <: Envelope[_]] = ApplicationHandler[UnsignedEnvelopeBox, E]
33.  type UnsignedEnvelopeBox[+E <: Envelope[_]] = Traced[Seq[Traced[SequencedEvent[E]]]]

    A batch of traced protocol events (without a signature).

    A batch of traced protocol events (without a signature). The outer Traced contains a trace context for the entire batch.

34.  type UnsignedProtocolEventHandler = ApplicationHandler[UnsignedEnvelopeBox, DefaultOpenEnvelope]