Type Members

1.  trait AcsCommitmentLookup extends AnyRef

   Read interface for ACS commitments, with no usage restrictions.

2.  trait AcsCommitmentStore extends AcsCommitmentLookup with PrunableByTime with AutoCloseable

   Read and write interface for ACS commitments.

   Read and write interface for ACS commitments. Apart from pruning, should only be used by the ACS commitment processor

3.  trait ActiveContractSnapshot extends AnyRef

   Provides snapshotting for active contracts.

4.  trait ActiveContractStore extends ActiveContractSnapshot with ConflictDetectionStore[LfContractId, Status]

   The active contract store (ACS) stores for every contract ID whether it is inexistent, ActiveContractStore.Active, ActiveContractStore.Archived, or ActiveContractStore.TransferredAway, along with the timestamp of the latest change.

   The active contract store (ACS) stores for every contract ID whether it is inexistent, ActiveContractStore.Active, ActiveContractStore.Archived, or ActiveContractStore.TransferredAway, along with the timestamp of the latest change. Every change is associated with the timestamp and request counter of the request that triggered the change. The changes are ordered first by timestamp, then by request counter, and finally by change type (activations before deactivations). Implementations must be thread-safe. Updates must be idempotent.

   Creations, transfers, and archivals can be mixed arbitrarily. A contract may be transferred-in and -out several times during its lifetime. It becomes active with every transfer-in and transferred away with every transfer-out. If the ACS detects irregularities, the change method reports them.

   These methods are supposed to be called by the ConflictDetector only, which coordinates the request journal updates and the updates to the ACS.

   Updates may be written asynchronously. Every implementation determines an order over all the changes and queries to the ACS. Each individual change must be applied atomically and the result is determined with respect to this order. This order need not be consistent with the order of the calls, though. However, the following is guaranteed: If the future returned by a call completes and observing the completion happens before another call, then all changes of the former call must be ordered before all changes of the later call.

   Bulk methods like ActiveContractStore.markContractsActive and ActiveContractStore.archiveContracts generate one individual change for each contract. So their changes may be interleaved with other calls.

   See also

   ActiveContractSnapshot for the ACS snapshot interface

5.  final case class CommandDeduplicationData extends PrettyPrinting with Product with Serializable

   The command deduplication data associated with a com.digitalasset.canton.ledger.participant.state.v2.ChangeId.

6.  trait CommandDeduplicationStore extends AutoCloseable
7.  final case class CommitTimeBeforeRequestTime(requestCounter: RequestCounter, requestTime: CantonTimestamp, commitTime: CantonTimestamp) extends RequestJournalStoreError with Product with Serializable
8.  trait CommitmentQueue extends AnyRef

   Manages the buffer (priority queue) for incoming commitments.

   Manages the buffer (priority queue) for incoming commitments.

   The priority is based on the timestamp of the end of the commitment's commitment period. Lower timestamps have higher priority.

9.  trait ConfigurationParamsDeserializer extends AnyRef
10.  trait ConflictDetectionStore[K, A <: PrettyPrinting] extends PrunableByTime

    Common interface for stores used by conflict detection

11.  trait ContractAndKeyLookup extends ContractLookup
12.  sealed trait ContractChange extends Product with Serializable with PrettyPrinting
13.  trait ContractKeyJournal extends ConflictDetectionStore[LfGlobalKey, Status]

    The contract key journal determines for each com.digitalasset.canton.protocol.LfGlobalKey whether it is considered to be allocated.

    The contract key journal determines for each com.digitalasset.canton.protocol.LfGlobalKey whether it is considered to be allocated. The store is organized as a journal, indexed by timestamp and request counter, so that crash recovery can remove all changes due to dirty request before replay starts.

    With unique contract key semantics and honest key maintainers, the allocation status reflects whether there is an active contract in the active contract store for the given key. However, if two or more contracts with the same key have been active, this correspondence no longer needs to hold. Then, the contract key journal has the authority over the allocation status of the key.

14.  trait ContractLookup extends AnyRef
15.  trait ContractLookupAndVerification extends ContractAndKeyLookup
16.  sealed trait ContractLookupError extends ContractStoreError
17.  trait ContractStore extends ContractLookup
18.  sealed trait ContractStoreError extends Product with Serializable with PrettyPrinting
19.  trait DamlPackageStore extends AutoCloseable

    For storing and retrieving Daml packages and DARs.

20.  final case class DefiniteAnswerEvent(offset: GlobalOffset, publicationTime: CantonTimestamp, submissionIdO: Option[LedgerSubmissionId])(traceContext: TraceContext) extends PrettyPrinting with Product with Serializable
    offset

    A completion offset in the MultiDomainEventLog

    publicationTime

    The publication time associated with the offset

    traceContext

    The trace context that created the completion offset.

21.  trait DomainAliasAndIdStore extends AutoCloseable

    Keeps track of domainIds of all domains the participant has previously connected to.

22.  trait DomainConnectionConfigStore extends AutoCloseable

    The configured domains and their connection configuration

23.  trait DomainParameterStore extends AnyRef
24.  sealed trait EventLogId extends PrettyPrinting with Product with Serializable
25.  class ExtendedContractLookup extends ContractLookupAndVerification

    A contract lookup that adds a fixed set of contracts to a backingContractLookup.

    A contract lookup that adds a fixed set of contracts to a backingContractLookup.

    Exceptions thrown

    java.lang.IllegalArgumentException if additionalContracts stores a contract under a wrong id

26.  trait HasPrunable extends AnyRef
27.  trait InFlightSubmissionStore extends AutoCloseable

    Backing store for com.digitalasset.canton.participant.protocol.submission.InFlightSubmissionTracker.

    Backing store for com.digitalasset.canton.participant.protocol.submission.InFlightSubmissionTracker.

    An in-flight submission is uniquely identified by its com.digitalasset.canton.ledger.participant.state.v2.ChangeId. com.digitalasset.canton.sequencing.protocol.MessageIds should be unique too, but this is not enforced by the store.

    Every change to an individual submissions must execute atomically. Bulk operations may interleave arbitrarily the atomic changes of the affected individual submissions and therefore need not be atomic as a whole.

28.  final case class InconsistentRequestTimestamp(requestCounter: RequestCounter, storedTimestamp: CantonTimestamp, expectedTimestamp: CantonTimestamp) extends RequestJournalStoreError with Product with Serializable
29.  trait IncrementalCommitmentStore extends AnyRef

    A key-value store with sets of parties as keys, and with LtHash16 values.

    A key-value store with sets of parties as keys, and with LtHash16 values. Keeps a watermark of the record time (a timestamp accompanied by a tie-breaker, to account for multiple changes with the same timestamp) of the last update.

    While the store is agnostic to its use, we use is as follows. For each set S of parties such that:

    • the parties are stakeholders on some contract C and
    • the participant stores C in its ACS

    the participant uses the store to store an LtHash16 commitment to all the contracts whose stakeholders are exactly S.

    To ensure that the commitments correspond to the ACSs, the caller(s) must jointly ensure that all ACS changes are delivered to this store exactly once. In particular, upon crashes, the caller(s) must send ALL ACS changes that are later - in the lexicographic order of (timestamp, request) - than the watermark returned by the store, but must not replay any changes lower or equal to the watermark.

30.  trait MultiDomainEventLog extends AutoCloseable

    The multi domain event log merges the events from several SingleDimensionEventLogs to a single event stream.

    The multi domain event log merges the events from several SingleDimensionEventLogs to a single event stream.

    The underlying SingleDimensionEventLog either refer to a domain ("domain event log") or to the underlying participant ("participant event log").

    Ordering guarantees: 1. Events belonging to the same SingleDimensionEventLog have the same relative order in the MultiDomainEventLog 2. Events are globally ordered such that any two (unpruned) events appear in the same relative order in different subscriptions and lookups.

31.  trait ParticipantEventLog extends SingleDimensionEventLog[ParticipantEventLogId] with AutoCloseable
32.  class ParticipantNodeEphemeralState extends AnyRef

    Some of the state of a participant that is not tied to a domain and is kept only in memory.

33.  class ParticipantNodePersistentState extends FlagCloseable with NamedLogging

    Some of the state of a participant that is not tied to a domain and must survive restarts.

    Some of the state of a participant that is not tied to a domain and must survive restarts. Does not cover topology stores (as they are also present for domain nodes) nor the RegisteredDomainsStore (for initialization reasons)

34.  trait ParticipantNodePersistentStateFactory extends AnyRef
35.  trait ParticipantPruningSchedulerStore extends PruningSchedulerStore

    Store for the participant pruning scheduler parameters such as the cron schedule, pruning retention period, and whether to only prune "internal" canton stores.

36.  trait ParticipantPruningStore extends AutoCloseable

    The ParticipantPruningStore stores the last started / completed pruning operation.

37.  trait ParticipantSettingsLookup extends AnyRef

    Read-only interface for ParticipantSettingsStore

38.  trait ParticipantSettingsStore extends ParticipantSettingsLookup with AutoCloseable

    Stores misc settings for a participant.

    Stores misc settings for a participant. Allows clients to read settings without accessing the database. In turn, a client needs to call refreshCache before reading settings.

39.  trait RegisteredDomainsStore extends DomainAliasAndIdStore
40.  trait RequestJournalStore extends AnyRef
41.  sealed trait RequestJournalStoreError extends Product with Serializable
42.  final case class SerializableCompletionInfo(completionInfo: CompletionInfo) extends Product with Serializable
43.  final case class SerializableRejectionReasonTemplate(rejectionReason: FinalReason) extends Product with Serializable
44.  final case class SerializableTransferredIn(transferIn: TransferredIn) extends Product with Serializable
45.  trait ServiceAgreementStore extends AutoCloseable
46.  trait SingleDimensionEventLog[+Id <: EventLogId] extends SingleDimensionEventLogLookup

    An event log for a single domain or for a domain-independent events (such as package uploads).

    An event log for a single domain or for a domain-independent events (such as package uploads). Supports out-of-order publication of events.

47.  trait SingleDimensionEventLogLookup extends AnyRef

    Read-only interface of SingleDimensionEventLog

48.  final case class StateChangeType(change: ContractChange, transferCounter: TransferCounterO) extends PrettyPrinting with Product with Serializable

    Type of state change of a contract as returned by com.digitalasset.canton.participant.store.ActiveContractStore.changesBetween through a com.digitalasset.canton.participant.store.ActiveContractSnapshot.ActiveContractIdsChange

49.  final case class StoredContract(contract: SerializableContract, requestCounter: RequestCounter, creatingTransactionIdO: Option[TransactionId]) extends PrettyPrinting with Product with Serializable

    Data to be stored for a contract.

    Data to be stored for a contract.

    contract

    The contract to be stored

    requestCounter

    The request counter of the latest request that stored the contract.

    creatingTransactionIdO

    The id of the transaction that created the contract. scala.None for divulged and witnessed contracts.

50.  final case class StoredDomainConnectionConfig(config: DomainConnectionConfig, status: Status) extends Product with Serializable
51.  trait SubmissionTrackerStore extends PrunableByTime with AutoCloseable
52.  class SyncDomainEphemeralState extends SyncDomainEphemeralStateLookup with NamedLogging with CloseableHealthComponent with AtomicHealthComponent

    The state of a synchronization domain that is kept only in memory and must be reconstructed after crashes and fatal errors from the SyncDomainPersistentState.

    The state of a synchronization domain that is kept only in memory and must be reconstructed after crashes and fatal errors from the SyncDomainPersistentState. The ephemeral state can be kept across network disconnects provided that the local processing continues as far as possible.

53.  trait SyncDomainEphemeralStateFactory extends AnyRef
54.  class SyncDomainEphemeralStateFactoryImpl extends SyncDomainEphemeralStateFactory with NamedLogging
55.  trait SyncDomainEphemeralStateLookup extends AnyRef
56.  trait SyncDomainPersistentState extends NamedLogging with AutoCloseable

    The state of a synchronization domain that is independent of the connectivity to the domain.

57.  trait SyncDomainPersistentStateOld extends SyncDomainPersistentState
58.  trait SyncDomainPersistentStateX extends SyncDomainPersistentState
59.  trait TransferLookup extends AnyRef
60.  trait TransferStore extends TransferLookup
61.  final case class UnknownContract(contractId: LfContractId) extends ContractLookupError with Product with Serializable
62.  final case class UnknownContracts(contractIds: Set[LfContractId]) extends ContractLookupError with Product with Serializable
63.  final case class UnknownRequestCounter(requestCounter: RequestCounter) extends RequestJournalStoreError with Product with Serializable