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 topologyChangeDelay valid at a given time or, if there is none in the store, the initial default value.

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

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.

Finds the topology transaction that first onboarded the mediator with ID mediatorId

Finds the topology transaction that first onboarded the sequencer with ID sequencerId

Finds the topology transaction that first onboarded the participant with ID participantId

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

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.

How often to poll to check that all tasks have completed.

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

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

Performs the task given by f unless a shutdown has been initiated. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosingF and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

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.

Performs the EitherT[Future] given by etf unless a shutdown has been initiated, in which case the provided error is returned instead. Both etf and the error are lazy; etf is only evaluated if there is no shutdown, the error only if we're shutting down. The shutdown will only begin after etf completes, but other tasks may execute concurrently with etf, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingF). The tasks are assumed to take less than closingTimeout to complete.

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

Use this method if closing/shutdown of the object should wait for asynchronous computation to finish too.

Performs the Future given by f unless a shutdown has been initiated. The future is lazy and not evaluated during shutdown. The shutdown will only begin after f completes, but other tasks may execute concurrently with f, if started using this function, or one of the other variants (performUnlessClosing and performUnlessClosingEitherT). The tasks are assumed to take less than closingTimeout to complete.

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.

Use this method if closing/shutdown of the object should wait for asynchronous computation to finish too.

Checks whether the given signed topology transaction has signatures (at this point still unvalidated) from signing keys, for which there aren't yet signatures in the store.

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

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.

update the dispatching watermark for this target store