returns the current dispatching watermark

for topology transaction dispatching, we keep track up to which point in time we have mirrored the authorized store to the remote store

the timestamp always refers to the timestamp of the authorized store!

Implementation specific parts of findCurrentAndUpcomingChangeDelays. Implementations must filter by validFrom, validUntil, sequenced, isProposal, and rejected. Implementations may or may not apply further filters. Implementations should not spend resources for sorting.

Yields transactions with validFrom strictly greater than timestampExclusive. Excludes rejected transactions and expired proposals.

Find all effective-time state changes. One EffectiveStateChange contains all positive transactions which have valid_from == fromEffectiveInclusive for the new state, and all positive transactions which have valid_until == fromEffectiveInclusive for the old/previous, but none of those transactions which meet both criteria (transient topology changes). This query does not return proposals, rejected transactions or removals.

Yields all transactions with sequenced time less than or equal to asOfInclusive. Sets validUntil to None, if validUntil is strictly greater than the maximum value of validFrom.

Yields all topologyChangeDelays that have expired within a given time period. Does not yield any proposals or rejections.

Returns initial set of onboarding transactions that should be dispatched to the synchronizer. Includes:

• SynchronizerTrustCertificates for the given participantId
• OwnerToKeyMappings for the given participantId
• NamespaceDelegations for the participantId's namespace
• The above even if they are expired.
• Transactions with operation REMOVE. Excludes:
• Proposals
• Rejected transactions
• Transactions that are not valid for synchronizerId

returns the set of positive transactions

this function is used by the topology processor to determine the set of transaction, such that we can perform cascading updates if there was a certificate revocation

Finds the last (i.e. highest id) stored transaction with validFrom strictly before asOfExclusive that has the same hash as transaction.

Finds the last (i.e. highest id) stored transaction with validFrom strictly before asOfExclusive that has the same hash as transaction and the representative protocol version for the given protocolVersion. Excludes rejected transactions.

fetch the effective time updates greater than or equal to a certain timestamp

this function is used to recover the future effective timestamp such that we can reschedule "pokes" of the topology client and updates of the acs commitment processor on startup

query optimized for inspection

Finds the transaction with maximum effective time that has been sequenced at or before sequencedTime and yields the sequenced / effective time of that transaction.

Updates topology transactions. The method proceeds as follows:

1. It expires all transactions tx with removeMapping.get(tx.mapping.uniqueKey).exists(tx.serial <= _). By expire we mean that valid_until is set to effective, provided valid_until was previously NULL and valid_from < effective. 2. It expires all transactions tx with tx.hash in removeTxs. 3. It adds all transactions in additions. Thereby: 3.1. It sets valid_until to effective, if there is a rejection reason or if expireImmediately.

TODO(#16601) Make this method private once PerformUnlessClosing doesn't need it any more

Blocks until all earlier tasks have completed and then prevents further tasks from being run.

Yields the currently valid and all upcoming topology change delays. Namely:

• The change delay with validFrom < sequencedTime and validUntil.forall(_ >= sequencedTime), or the initial default value, if no such change delay exists.
• All change delays with validFrom >= sequencedTime and sequenced < sequencedTime. Excludes:
• Proposals
• Rejected transactions
• Transactions with validUntil.contains(validFrom)

The result is sorted descending by validFrom. So the current change delay comes last.

Check whether we're closing. Susceptible to race conditions; unless you're using this as a flag to the retry lib or you really know what you're doing, prefer performUnlessClosing and friends.

Set this to true to get detailed information about all futures that did not complete during shutdown.

Blocks until all earlier tasks have completed and then prevents further tasks from being run.

TODO(#16601) Make this method private once PerformUnlessClosing doesn't need it any more

Schedules the given task to be run upon closing.

Register a task to run when closing is initiated, or run it immediately if closing is already ongoing. Unlike runOnClose, this method does not guarantee that this task will have run by the time the LifeCycleManager's closeAsync method completes or AutoCloseable's close returns. This is because the task is run immediately if the component has already been closed.

Variant of runOnOrAfterClose that does not return a com.digitalasset.canton.lifecycle.LifeCycleRegistrationHandle.

Runs the computation f only if the component is not yet closing. If so, the component will delay releasing its resources until f has completed (as defined by the com.digitalasset.canton.util.Thereafter instance) or the synchronizeWithClosingPatience has elapsed.

DO NOT CALL this.close as part of f, because it will result in a deadlock. DO NOT PUT retries, especially indefinite ones, inside f.

Convenience method for synchronizing on Futures instead of FutureUnlessShutdowns. Equivalent to

synchronizeWithClosing(name)(FutureUnlessShutdown.outcomeF(f))

Runs the computation f only if the component is not yet closing. If so, the component will delay releasing its resources until f has finished or the synchronizeWithClosingPatience has elapsed.

DO NOT CALL this.close as part of f, because it will result in a deadlock. DO NOT PUT retries, especially indefinite ones, inside f.

Runs the computation f only if the component is not yet closing. If so, the component will delay releasing its resources until f has completed (as defined by the com.digitalasset.canton.util.Thereafter instance) or the synchronizeWithClosingPatience has elapsed.

DO NOT CALL this.close as part of f, because it will result in a deadlock. DO NOT PUT retries, especially indefinite ones, inside f.

Runs the computation fa unless isClosing returns true.

This method does not delay the closing while fa is running, unlike the methods in HasSynchronizeWithClosing. Accordingly, this method is useful for intermittent checks whether the result of the computation is still relevant.