Type Members

1.  class AcsCommitmentBenchmark extends HasExecutorServiceGeneric with Matchers with Inspectors with TestEssentials with FlagCloseable with HasCloseContext

   Annotations

   @SuppressWarnings() @State() @Warmup() @Measurement() @Fork()

2.  class AcsCommitmentBenchmarkCatchupConfig extends AcsCommitmentBenchmark

   This benchmark measure the impact of catchupIntervalSkip, by skipping intervals we perform less computations are able to do these faster.

   This benchmark measure the impact of catchupIntervalSkip, by skipping intervals we perform less computations are able to do these faster. "100000" is used as the last value to give a comparative benchmark when there is no catch up happening.

   Annotations

   @SuppressWarnings()

3.  class AcsCommitmentBenchmarkLoad extends AcsCommitmentBenchmark

   This benchmark measures the impact on performance when the amount of counter participants increases.

   This benchmark measures the impact on performance when the amount of counter participants increases. Increasing the amount of participants should negatively impact performance. Massive should have a highly reduced amount compared to x3, since x3 causes many more stakeholder groups to be generated (and more computations needed).

   Annotations

   @SuppressWarnings()

4.  class AcsCommitmentMultiHostedPartyTracker extends FlagCloseable with NamedLogging
5.  class AcsCommitmentProcessor extends AcsChangeListener with FlagCloseable with NamedLogging

   Computes, sends, receives and compares ACS commitments

   Computes, sends, receives and compares ACS commitments

   In more detail:

   • The class computes the participant's ACS commitments (for each of the participant's "counter-participants", i.e., participants who host a stakeholder of some contract in participant's ACS). The commitments are computed at specified (sequencer) times that are configured by the synchronizer and are uniform for all participants connected to the synchronizer. We refer to them as "commitment ticks". The commitments must be computed "online", i.e., after the state of the ACS at a commitment tick becomes known.
   • After the commitments for a tick are computed, they should be distributed to the counter-participants; but this is best-effort.
   • The class processes the ACS commitments from counter-participants (method processBatch):
     • it checks that the commitments are properly signed
     • it checks that they match the locally computed ACS commitments
   • The class must define crash recovery points, such that the class itself combined with startup procedures of the node jointly ensure that the participant doesn't neglect to send its ACS commitments or process the remote ones. We allow the participant to send the same commitments multiple times in case of a crash, and we do allow the participant to not send some commitments in some edge cases due to crashes.
   • Finally, the class supports pruning: it computes the safe timestamps for participant pruning, such that, after pruning, non-repudiation still holds for any contract in the ACS

   The first four pieces of class functionality must be appropriately synchronized:

   • ACS commitments for a tick cannot be completely processed before the local commitment for that tick is computed. Note that the class cannot make many assumptions on the received commitments: the counter-participants can send them in any order, and they can either precede or lag behind the local commitment computations.
   • The recovery points must be chosen such that the participant computes its local commitments correctly, and never misses to compute a local commitment for every tick. Otherwise, the participant will start raising false alarms when remote commitments are received (either because it computes the wrong thing, or because it doesn't compute anything at all and thus doesn't expect to receive anything).

   Additionally, the startup procedure must ensure that:

   • processBatch is called for every sequencer message that contains commitment messages and whose handling hasn't yet completed successfully
   • publish is called for every change to the ACS after com.digitalasset.canton.participant.store.IncrementalCommitmentStore.watermark. where the request counter is to be used as a tie-breaker.

   On first time startup (no entries in database) a single outstanding row will be generated for a previous fictive period, of length one reconciliation interval; this is to generate a starting point going forward.

   Finally, the class requires the reconciliation interval to be a multiple of 1 second.

   The commitmentPeriodObserver is called whenever a commitment is computed for a period, except if the participant crashes. If publish is called multiple times for the same timestamp (once before a crash and once after the recovery), the observer may also be called twice for the same period.

   When a participant's ACS commitment processor falls behind some counter participants' processors, the participant has the option to enter a so-called "catch-up mode". In catch-up mode, the participant skips sending and checking commitments for some reconciliation intervals. The parameter governing catch-up mode is:

   Annotations

   @SuppressWarnings()

6.  final case class CommitmentContractMetadata(cid: LfContractId, reassignmentCounter: ReassignmentCounter)(representativeProtocolVersion: RepresentativeProtocolVersion[CommitmentContractMetadata.type]) extends HasProtocolVersionedWrapper[CommitmentContractMetadata] with PrettyPrinting with Product with Serializable
7.  final case class CommitmentInspectContract(cid: LfContractId, activeOnExpectedSynchronizer: Boolean, contract: Option[SerializableContract], state: Seq[ContractStateOnSynchronizer])(representativeProtocolVersion: RepresentativeProtocolVersion[CommitmentInspectContract.type]) extends HasProtocolVersionedWrapper[CommitmentInspectContract] with PrettyPrinting with Product with Serializable
8.  final case class CommitmentMismatchInfo(synchronizerId: SynchronizerId, timestamp: CantonTimestamp, participant: ParticipantId, counterParticipant: ParticipantId, mismatches: Seq[ContractMismatchInfo]) extends PrettyPrinting with Product with Serializable
9.  final case class CompareCmtContracts(cidsOnlyFirst: Seq[LfContractId], cidsOnlySecond: Seq[LfContractId], differentReassignmentCounters: Seq[LfContractId]) extends Product with Serializable
10.  sealed trait ContractActive extends ContractState
11.  final case class ContractArchived()(representativeProtocolVersion: RepresentativeProtocolVersion[ContractArchived.type]) extends ContractInactive with HasProtocolVersionedWrapper[ContractArchived] with Product with Serializable
12.  final case class ContractAssigned(reassignmentCounterTarget: ReassignmentCounter, reassignmentId: Option[ReassignmentId])(representativeProtocolVersion: RepresentativeProtocolVersion[ContractAssigned.type]) extends ContractActive with HasProtocolVersionedWrapper[ContractAssigned] with Product with Serializable
13.  final case class ContractCreated()(representativeProtocolVersion: RepresentativeProtocolVersion[ContractCreated.type]) extends ContractActive with HasProtocolVersionedWrapper[ContractCreated] with Product with Serializable
14.  final case class ContractDefinition(counterParticipants: Set[ParticipantId], stakeholderGroups: Set[StakeholderGroup], reassignmentCounter: ReassignmentCounter = ReassignmentCounter.Genesis) extends Product with Serializable
15.  sealed trait ContractInactive extends ContractState
16.  final case class ContractMismatchInfo(contract: SerializableContract, reason: MismatchReason) extends PrettyPrinting with Product with Serializable
17.  sealed trait ContractState extends Product with Serializable with PrettyPrinting
18.  final case class ContractStateOnSynchronizer(synchronizerId: SynchronizerId, contractState: ContractState)(representativeProtocolVersion: RepresentativeProtocolVersion[ContractStateOnSynchronizer.type]) extends HasProtocolVersionedWrapper[ContractStateOnSynchronizer] with PrettyPrinting with Product with Serializable
19.  final case class ContractUnassigned(targetSynchronizerId: SynchronizerId, reassignmentCounterSrc: ReassignmentCounter, reassignmentId: Option[ReassignmentId])(representativeProtocolVersion: RepresentativeProtocolVersion[ContractUnassigned.type]) extends ContractInactive with HasProtocolVersionedWrapper[ContractUnassigned] with Product with Serializable
20.  final case class ContractUnknown()(representativeProtocolVersion: RepresentativeProtocolVersion[ContractUnknown.type]) extends ContractInactive with HasProtocolVersionedWrapper[ContractUnknown] with Product with Serializable
21.  final case class DeactivatedContract(participantWithContract: ParticipantId, active: ContractActive, participantWithoutContract: ParticipantId, inactive: ContractInactive, whereActive: Option[ContractActive]) extends MismatchReason with PrettyPrinting with Product with Serializable
22.  final case class DifferentReassignmentCounters(participant1: ParticipantId, active1: ContractActive, participant2: ParticipantId, active2: ContractActive) extends MismatchReason with PrettyPrinting with Product with Serializable
23.  sealed trait MismatchReason extends Product with Serializable with PrettyPrinting
24.  class PruningProcessor extends NamedLogging with FlagCloseable with HasCloseContext

    The pruning processor coordinates the pruning of all participant node stores

25.  final case class SortedReconciliationIntervals extends Product with Serializable

    Reconciliation intervals, with their validity intervals, sorted by validFrom in decreasing order.

    Reconciliation intervals, with their validity intervals, sorted by validFrom in decreasing order. Note: the factory method ensures that the intervals are pairwise disjoint.

26.  class SortedReconciliationIntervalsProvider extends NamedLogging
27.  class SortedReconciliationIntervalsProviderFactory extends NamedLogging
28.  final case class StakeholderGroup(parties: Set[LfPartyId], activeContractIds: Seq[LfContractId], passiveContractIds: Seq[LfContractId]) extends Product with Serializable
29.  sealed class StakeholderGroupType extends AnyRef
30.  sealed trait TrackedPeriodState extends AnyRef
31.  final case class UnknownContract(participantWithContract: ParticipantId, active: ContractActive, participantWithoutContract: ParticipantId) extends MismatchReason with Product with Serializable