Type Members

1.  abstract class CheckedSubscriptionErrorRetryPolicy[SE <: SubscriptionError] extends SubscriptionErrorRetryPolicy

   Allows implementors to only specify policy for an error hierarchy they've defined.

   Allows implementors to only specify policy for an error hierarchy they've defined. Avoids adding type parameters to all sequencer client components. TODO(danilo): work out if type parameters are really required and if so are they that bad

2.  trait DelaySequencedEvent extends AnyRef
3.  case class DelayedSequencerClient(domain: DomainId, member: String) extends DelaySequencedEvent with Product with Serializable
4.  case class EventValidatorFactoryArgs(initialLastEventProcessedMetadataO: Option[SequencedEventMetadata], unauthenticated: Boolean) extends Product with Serializable

   settings to control the behaviour of the sequenced event validation factory

5.  case class Fatal(msg: String) extends SequencerSubscriptionCreationError with Product with Serializable

   When a fatal error occurs on the creation of a sequencer subscription, the com.digitalasset.canton.sequencing.client.ResilientSequencerSubscription will not retry the subscription creation.

   When a fatal error occurs on the creation of a sequencer subscription, the com.digitalasset.canton.sequencing.client.ResilientSequencerSubscription will not retry the subscription creation. Instead, the subscription will fail.

6.  sealed trait GrpcSequencerAuthenticationSupport extends AnyRef
7.  class PeriodicAcknowledgements extends NamedLogging with FlagCloseable with HasFlushFuture

   Periodically pull the latest clean timestamp and if it has changed acknowledge it with the sequencer.

   Periodically pull the latest clean timestamp and if it has changed acknowledge it with the sequencer. This indicates that we have successfully processed all events up to and including this event. We always acknowledge the current clean timestamp on startup if available to indicate to the sequencer that we are running. The periodic interval is based on the host clock not in sequencer time, however any drift is likely insignificant for the purpose of the sequencer acknowledgements (pruning hourly/daily). Errors are logged at error level - periodic failures are likely not problematic however continuous errors could eventually be problematic for the sequencer operator.

8.  case class RecordingConfig(directory: Path, filename: Option[String] = None) extends Product with Serializable

   Configuration for where to record sequencer sends and events to.

   Configuration for where to record sequencer sends and events to.

   directory

   Root directory for holding all recording files

   filename

   Filename that is initially empty and updated to a name based on the member-id at runtime. Use setFilename to ensure this can only be set once.

9.  sealed trait ReplayAction extends AnyRef
10.  case class ReplayConfig(recordingConfig: RecordingConfig, action: ReplayAction) extends Product with Serializable

    Configuration for setting up a sequencer client to replay requests or received events.

    Configuration for setting up a sequencer client to replay requests or received events.

    recordingConfig

    The path to where all recorded content is stored

    action

    What type of replay we'll be performing

11.  class ResilientSequencerSubscription[HandlerError] extends SequencerSubscription[HandlerError] with NamedLogging with FlagCloseableAsync with HasDegradationState[Warn]
12.  sealed trait SendAsyncClientError extends Product with Serializable with PrettyPrinting

    Errors returned from the AsyncSend where we are sure the request has not potentially been accepted by the server so may be retried using a new message id (as a tracked message id for the failed request may remain in the pending send set).

    Errors returned from the AsyncSend where we are sure the request has not potentially been accepted by the server so may be retried using a new message id (as a tracked message id for the failed request may remain in the pending send set). If a technical error is encountered by the sequencer client where there is a chance that the send will be sequenced it should not be returned to the caller through this error.

13.  type SendCallback = (SendResult) => Unit

    Signature for callbacks provided to the send operation to take advantage of the SendTracker to provide tracking of the eventual send result.

    Signature for callbacks provided to the send operation to take advantage of the SendTracker to provide tracking of the eventual send result. Callback is ephemeral and will be lost if the SequencerClient is recreated or the process exits.

    See also

    SequencerClient.sendAsync

14.  class SendCallbackWithFuture extends SendCallback
15.  sealed trait SendResult extends Product with Serializable

    Possible outcomes for a send operation can be observed by a SequencerClient

16.  type SendTimeoutHandler = (MessageId) => EitherT[Future, TimeoutHandlerError, Unit]

    Signature for handlers that are notified that the sequencer clock has progressed beyond the max sequencing time of a send previously done by the client and receipt has not been witnessed.

    Signature for handlers that are notified that the sequencer clock has progressed beyond the max sequencing time of a send previously done by the client and receipt has not been witnessed. It's currently unclear what we'll do when handling these timeouts so the error type is left intentionally undefined.

17.  class SendTracker extends NamedLogging with AutoCloseable

    When a we make a send request to the sequencer it will not be sequenced until some point in the future and may not be sequenced at all.

    When a we make a send request to the sequencer it will not be sequenced until some point in the future and may not be sequenced at all. To track a request call send with the messageId and max-sequencing-time of the request, the tracker then observes sequenced events and will notify the provided handler if the send times out.

18.  sealed trait SendType extends AnyRef

    What type of message is being sent.

    What type of message is being sent. Used by the domain and surrounding infrastructure for prioritizing send requests.

19.  case class SequencedEventMetadata(counter: SequencerCounter, timestamp: CantonTimestamp, hash: Option[Hash]) extends Product with Serializable

    Metadata of a protocol.SequencedEvent.

    Metadata of a protocol.SequencedEvent. Used by the sequencer client to persist details of the last event it has seen but where we don't need details of its content.

    counter

    The counter value assigned to the event

    timestamp

    The timestamp assigned to the event

    hash

    The hash of the event contents that is also used for signing the event None for ignored sequenced events.

20.  sealed trait SequencedEventValidationError extends AnyRef
21.  class SequencedEventValidator extends ValidateSequencedEvent with NamedLogging

    Validate whether a received event is valid for processing.

22.  class SequencerClient extends FlagCloseableAsync with NamedLogging with HasFlushFuture with Spanning

    The sequencer client facilitates access to the individual domain sequencer.

    The sequencer client facilitates access to the individual domain sequencer. A client centralizes the message signing operations, as well as the handling and storage of message receipts and delivery proofs, such that this functionality does not have to be duplicated throughout the participant node.

23.  case class SequencerClientConfig(eventInboxSize: NonNegativeInt = NonNegativeInt.tryCreate(100), startupConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(1), initialConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMillis(10), warnDisconnectDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5), maxConnectionRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(30), handshakeRetryAttempts: NonNegativeInt = NonNegativeInt.tryCreate(50), handshakeRetryDelay: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofSeconds(5), defaultMaxSequencingTimeOffset: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(5), acknowledgementInterval: NonNegativeFiniteDuration = NonNegativeFiniteDuration.ofMinutes(1), keepAliveClient: Option[KeepAliveClientConfig] = Some(KeepAliveClientConfig()), authToken: AuthenticationTokenManagerConfig = AuthenticationTokenManagerConfig(), optimisticSequencedEventValidation: Boolean = true, skipSequencedEventValidation: Boolean = false) extends Product with Serializable

    Client configured options for how to connect to a sequencer

    Client configured options for how to connect to a sequencer

    eventInboxSize

    The size of the inbox queue used to store received events. Must be at least one. Events in the inbox are processed in parallel. A larger inbox may result in higher throughput at the price of higher memory consumption, larger database queries, and longer crash recovery.

    startupConnectionRetryDelay

    Initial delay before we attempt to establish an initial connection

    initialConnectionRetryDelay

    Initial delay before a reconnect attempt

    warnDisconnectDelay

    Consider sequencer to be degraded after delay

    maxConnectionRetryDelay

    Maximum delay before a reconnect attempt

    handshakeRetryAttempts

    How many attempts should we make to get a handshake response

    handshakeRetryDelay

    How long to delay between attempts to fetch a handshake response

    defaultMaxSequencingTimeOffset

    if no max-sequencing-time is supplied to send, our current time will be offset by this amount

    acknowledgementInterval

    Controls how frequently the client acknowledges how far it has successfully processed to the sequencer which allows the sequencer to remove this data when pruning.

    authToken

    configuration settings for the authentication token manager

    optimisticSequencedEventValidation

    if true, sequenced event signatures will be validated first optimistically and only strict if the optimistical evaluation failed. this means that for a split second, we might still accept an event signed with a key that has just been revoked.

    skipSequencedEventValidation

    if true, sequenced event validation will be skipped. the default setting is false. this option should only be enabled if a defective validation is blocking processing. therefore, unless you know what you are doing, you shouldn't touch this setting.

24.  trait SequencerClientFactory extends AnyRef
25.  sealed trait SequencerClientSubscriptionError extends Product with Serializable
26.  case class SequencerClientSubscriptionException(error: SequencerClientSubscriptionError) extends RuntimeException with Product with Serializable

    Annotations

    @SuppressWarnings()

27.  trait SequencerSubscription[HandlerError] extends FlagCloseableAsync with NamedLogging

    A running subscription to a sequencer.

    A running subscription to a sequencer. Can be closed by the consumer or the producer. Once closed the closeReason value will be fulfilled with the reason the subscription was closed. Implementations are expected to immediately start their subscription unless otherwise stated. If close is called while the handler is running closeReason should not be completed until the handler has completed.

28.  sealed trait SequencerSubscriptionCreationError extends SubscriptionError

    Errors that may occur on the creation of a sequencer subscription

29.  sealed trait SubscriptionCloseReason[+E] extends AnyRef

    Why did the sequencer subscription terminate

30.  trait SubscriptionErrorRetryPolicy extends AnyRef

    Policy for what errors are considered retryable.

    Policy for what errors are considered retryable. Each transports.SequencerClientTransport is expected to supply their own policy which can consider error types they have defined.

31.  trait SubscriptionRetryDelayRule extends AnyRef

    Calculator for how to select the next retry duration and specifies what duration is enough to log a warning.

32.  trait ValidateSequencedEvent extends AnyRef

    Validate whether a received event is valid for processing.