Type Members

1.  trait AcsCommitmentLookup extends AnyRef

   Read interface for ACS commitments, with no usage restrictions.

2.  trait AcsCommitmentStore extends AcsCommitmentLookup with PrunableByTime[AcsCommitmentStoreError] 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, AcsError]

   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 com.digitalasset.canton.participant.protocol.conflictdetection.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.createContracts 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.  case class CommandDeduplicationData extends PrettyPrinting with NoCopy with Product with Serializable

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

6.  trait CommandDeduplicationStore extends AutoCloseable
7.  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, E] extends PrunableByTime[E]

    Common interface for stores used by conflict detection

11.  trait ContractAndKeyLookup extends ContractLookup
12.  trait ContractKeyJournal extends ConflictDetectionStore[LfGlobalKey, Status, ContractKeyJournalError]

    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.

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

    For storing and retrieving Daml packages and DARs.

18.  case class DefiniteAnswerEvent(offset: GlobalOffset, publicationTime: CantonTimestamp, submissionId: 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.

19.  trait DomainAliasAndIdStore extends AutoCloseable

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

20.  trait DomainConnectionConfigStore extends AutoCloseable

    The configured domains and their connection configuration

21.  trait DomainParameterStore extends AnyRef
22.  final case class DuplicateContract(id: LfContractId, oldContract: StoredContract, newContract: StoredContract) extends ContractStoreError with Product with Serializable
23.  sealed trait EventLogId extends PrettyPrinting with Product with Serializable
24.  class ExtendedContractLookup extends ContractAndKeyLookup

    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

25.  trait HasPrunable extends AnyRef
26.  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.daml.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.

27.  case class InconsistentRequestState(requestCounter: RequestCounter, storedState: RequestState, expectedState: RequestState) extends RequestJournalStoreError with Product with Serializable
28.  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 MultiDomainCausalityStore extends AutoCloseable
31.  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.

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

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

34.  class ParticipantNodePersistentState extends AutoCloseable 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)

35.  trait ParticipantPruningStore extends AutoCloseable

    The ParticipantPruningStore stores the last started / completed pruning operation.

36.  trait ParticipantSettingsLookup extends AnyRef

    Read-only interface for ParticipantSettingsStore

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

38.  trait RegisteredDomainsStore extends DomainAliasAndIdStore
39.  trait RequestJournalStore extends AnyRef
40.  sealed trait RequestJournalStoreError extends Product with Serializable
41.  case class SerializableBlindingInfo(blindingInfo: BlindingInfo) extends HasProtoV0[BlindingInfo] with Product with Serializable
42.  case class SerializableCommandRejected(commandRejected: CommandRejected) extends HasProtoV0[CommandRejected] with Product with Serializable
43.  case class SerializableCompletionInfo(completionInfo: CompletionInfo) extends HasProtoV0[CompletionInfo] with Product with Serializable
44.  case class SerializableConfiguration(configuration: Configuration) extends HasProtoV0[Configuration] with Product with Serializable
45.  case class SerializableConfigurationChangeRejected(configurationChangeRejected: ConfigurationChangeRejected) extends HasProtoV0[ConfigurationChangeRejected] with Product with Serializable
46.  case class SerializableConfigurationChanged(configurationChanged: ConfigurationChanged) extends HasProtoV0[ConfigurationChanged] with Product with Serializable
47.  case class SerializableDivulgedContract(divulgedContract: DivulgedContract) extends HasProtoV0[DivulgedContract] with Product with Serializable
48.  case class SerializableLedgerSyncEvent(ledgerSyncEvent: LedgerSyncEvent) extends HasVersionedWrapper[VersionedLedgerSyncEvent] with HasProtoV0[protocol.v0.LedgerSyncEvent] with Product with Serializable

    Wrapper for converting a LedgerSyncEvent to its protobuf companion.

    Wrapper for converting a LedgerSyncEvent to its protobuf companion. Currently only Intended only for storage due to the unusual exceptions which are thrown that are only permitted in a storage context.

    Exceptions thrown

    canton.store.db.DbDeserializationException if transactions or contracts fail to deserialize

    canton.store.db.DbSerializationException if transactions or contracts fail to serialize

49.  case class SerializableLfTimestamp(timestamp: Timestamp) extends HasProtoV0[Timestamp] with Product with Serializable
50.  case class SerializableNodeSeed(nodeId: LfNodeId, seedHash: Hash) extends HasProtoV0[NodeSeed] with Product with Serializable
51.  case class SerializablePartyAddedToParticipant(partyAddedToParticipant: PartyAddedToParticipant) extends HasProtoV0[PartyAddedToParticipant] with Product with Serializable
52.  case class SerializablePartyAllocationRejected(partyAllocationRejected: PartyAllocationRejected) extends HasProtoV0[PartyAllocationRejected] with Product with Serializable
53.  case class SerializablePublicPackageUpload(publicPackageUpload: PublicPackageUpload) extends HasProtoV0[PublicPackageUpload] with Product with Serializable
54.  case class SerializablePublicPackageUploadRejected(publicPackageUploadRejected: PublicPackageUploadRejected) extends HasProtoV0[PublicPackageUploadRejected] with Product with Serializable
55.  case class SerializableRejectionReasonTemplate(rejectionReason: RejectionReasonTemplate) extends HasProtoV0[GrpcRejectionReasonTemplate] with Product with Serializable
56.  case class SerializableSubmissionId(submissionId: LedgerSubmissionId) extends Product with Serializable
57.  case class SerializableTimeModel(timeModel: LedgerTimeModel) extends HasProtoV0[TimeModel] with Product with Serializable
58.  case class SerializableTransactionAccepted(transactionAccepted: TransactionAccepted) extends HasProtoV0[TransactionAccepted] with Product with Serializable
59.  case class SerializableTransactionMeta(transactionMeta: TransactionMeta) extends HasProtoV0[TransactionMeta] with Product with Serializable
60.  trait ServiceAgreementStore extends AutoCloseable
61.  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.

62.  trait SingleDimensionEventLogLookup extends AnyRef

    Read-only interface of SingleDimensionEventLog

63.  trait SingleDomainCausalDependencyStore extends AnyRef
64.  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.

65.  class StoredContractManager extends NamedLogging with ContractLookup

    Manages a contract store by keeping pending contracts in memory.

    Manages a contract store by keeping pending contracts in memory. ContractLookup.lookup finds these pending contracts in addition to those in the backing ContractStore. A contract ceases to be pending as soon as first request writes it to the backing store using StoredContractManager.commitIfPending.

    Unlike ExtendedContractLookup, the pending contracts can be updated and committed to the backing store, concurrently with other contract lookups and additions.

66.  class SyncDomainEphemeralState extends SyncDomainEphemeralStateLookup with AutoCloseable with NamedLogging

    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.

67.  trait SyncDomainEphemeralStateFactory extends AnyRef
68.  class SyncDomainEphemeralStateFactoryImpl extends SyncDomainEphemeralStateFactory with NamedLogging
69.  trait SyncDomainEphemeralStateLookup extends AnyRef
70.  trait SyncDomainPersistentState extends NamedLogging with AutoCloseable

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

71.  class SyncDomainPersistentStateFactory extends NamedLogging

    Factory for SyncDomainPersistentState.

    Factory for SyncDomainPersistentState. Tries to discover existing persistent states or create new ones and checks consistency of domain parameters and unique contract key domains

72.  trait TransferLookup extends AnyRef
73.  trait TransferStore extends TransferLookup
74.  final case class UnknownContract(contractId: LfContractId) extends ContractLookupError with Product with Serializable
75.  final case class UnknownContracts(contractIds: Set[LfContractId]) extends ContractLookupError with Product with Serializable
76.  case class UnknownRequestCounter(requestCounter: RequestCounter) extends RequestJournalStoreError with Product with Serializable