Type Members

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

   An application handler processes boxed envelopes and returns a HandlerResult

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

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

3.  type BoxedEnvelope[+Box[+_], +Env] = 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[+_]] 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.  final case class GrpcSequencerConnection(endpoints: NonEmpty[Seq[Endpoint]], transportSecurity: Boolean, customTrustCertificates: Option[ByteString]) extends SequencerConnection with Product with Serializable
7.  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.

8.  case class HttpSequencerConnection(urls: HttpSequencerEndpoints, certificate: X509CertificatePem) extends SequencerConnection with Product with Serializable
9.  type OrdinaryApplicationHandler[-E] = ApplicationHandler[OrdinaryEnvelopeBox, E]
10.  type OrdinaryEnvelopeBox[+E] = Traced[Seq[OrdinarySequencedEvent[E]]]

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

11.  type OrdinaryProtocolEvent = OrdinarySequencedEvent[DefaultOpenEnvelope]

    Default type for deserialized events.

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

12.  type OrdinarySerializedEvent = OrdinarySequencedEvent[ClosedEnvelope]

    Default type for serialized events.

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

13.  type PossiblyIgnoredApplicationHandler[-E] = ApplicationHandler[PossiblyIgnoredEnvelopeBox, E]
14.  type PossiblyIgnoredEnvelopeBox[+E] = Traced[Seq[PossiblyIgnoredSequencedEvent[E]]]

    Default box for PossiblyIgnoredProtocolEvents.

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

15.  type PossiblyIgnoredProtocolEvent = PossiblyIgnoredSequencedEvent[DefaultOpenEnvelope]

    Deserialized event with optional payload.

16.  type PossiblyIgnoredSerializedEvent = PossiblyIgnoredSequencedEvent[ClosedEnvelope]
17.  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.

18.  type RawSignedContentEnvelopeBox[+Env] = 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.

19.  type RawSignedContentSerializedEvent = SignedContent[SequencedEvent[ClosedEnvelope]]
20.  sealed trait ResubscriptionStart extends Product with Serializable with PrettyPrinting

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

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

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

22.  sealed trait SequencerConnection extends Product with Serializable with HasVersionedWrapper[VersionedMessage[SequencerConnection]] with HasProtoV0[protocol.v0.SequencerConnection] with 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.

23.  type SerializedEventHandler[Err] = (OrdinarySerializedEvent) => Future[Either[Err, Unit]]

    Default type for handlers on serialized events with error reporting

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

25.  type UnsignedApplicationHandler[-E] = ApplicationHandler[UnsignedEnvelopeBox, E]
26.  type UnsignedEnvelopeBox[+E] = 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.

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