class CantonSyncService extends WriteService with WriteParticipantPruningService with ReadService with FlagCloseable with Spanning with NamedLogging with HasCloseContext

Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. CantonSyncService
  2. HasCloseContext
  3. PromiseUnlessShutdownFactory
  4. NamedLogging
  5. Spanning
  6. FlagCloseable
  7. PerformUnlessClosing
  8. OnShutdownRunner
  9. AutoCloseable
  10. ReadService
  11. WriteService
  12. ReportsHealth
  13. WriteParticipantPruningService
  14. WriteConfigService
  15. WritePartyService
  16. WritePackagesService
  17. AnyRef
  18. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new CantonSyncService(participantId: ParticipantId, domainRegistry: DomainRegistry, domainConnectionConfigStore: DomainConnectionConfigStore, aliasManager: DomainAliasManager, participantNodePersistentState: Eval[ParticipantNodePersistentState], participantNodeEphemeralState: ParticipantNodeEphemeralState, syncDomainPersistentStateManager: SyncDomainPersistentStateManager, packageService: PackageService, topologyManagerOps: ParticipantTopologyManagerOps, identityPusher: ParticipantTopologyDispatcherCommon, partyNotifier: LedgerServerPartyNotifier, syncCrypto: SyncCryptoApiProvider, pruningProcessor: PruningProcessor, engine: Engine, syncDomainStateFactory: SyncDomainEphemeralStateFactory, clock: Clock, resourceManagementService: ResourceManagementService, parameters: ParticipantNodeParameters, syncDomainFactory: Factory[SyncDomain], indexedStringStore: IndexedStringStore, storage: Storage, metrics: ParticipantMetrics, sequencerInfoLoader: SequencerInfoLoader, isActive: () => Boolean, futureSupervisor: FutureSupervisor, loggerFactory: NamedLoggerFactory, skipRecipientsCheck: Boolean, multiDomainLedgerAPIEnabled: Boolean)(implicit ec: ExecutionContext, mat: Materializer, tracer: Tracer)

    participantId

    The participant node id hosting this sync service.

    domainRegistry

    Domain registry for connecting to domains.

    domainConnectionConfigStore

    Storage for domain connection configs

    packageService

    Underlying package management service.

    syncCrypto

    Synchronisation crypto utility combining IPS and Crypto operations.

    isActive

    Returns true of the node is the active replica

Type Members

  1. type ConnectionListener = (DomainAlias) => Unit

Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##: Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def addDomain(config: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[Future, SyncServiceError, Unit]

    Adds a new domain to the sync service's configuration.

    Adds a new domain to the sync service's configuration.

    NOTE: Does not automatically connect the sync service to the new domain.

    config

    The domain configuration.

    returns

    Error or unit.

  5. def allocateParty(hint: Option[LfPartyId], displayName: Option[String], rawSubmissionId: LedgerSubmissionId)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]

    Adds a new party to the set managed by the ledger.

    Adds a new party to the set managed by the ledger.

    Caller specifies a party identifier suggestion, the actual identifier allocated might be different and is implementation specific.

    In particular, a ledger may: - Disregard the given hint and choose a completely new party identifier - Construct a new unique identifier from the given hint, e.g., by appending a UUID - Use the given hint as is, and reject the call if such a party already exists

    Successful party allocations will result in a com.digitalasset.canton.ledger.participant.state.v2.Update.PartyAddedToParticipant message. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates and com.digitalasset.canton.ledger.participant.state.v2.Update for further details.

    hint

    A party identifier suggestion

    displayName

    A human readable name of the new party

    returns

    an async result of a SubmissionResult

    Definition Classes
    CantonSyncService → WritePartyService
  6. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  7. def cancelShutdownTask(token: Long): Unit

    Removes a shutdown task from the list using a token returned by runOnShutdown

    Removes a shutdown task from the list using a token returned by runOnShutdown

    Definition Classes
    OnShutdownRunner
  8. val cantonAuthorityResolver: AuthorityResolver
  9. def checkOverloaded(traceContext: TraceContext): Option[SubmissionResult]
  10. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
  11. final def close(): Unit

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

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

    Definition Classes
    FlagCloseable → OnShutdownRunner → AutoCloseable
  12. implicit val closeContext: CloseContext
    Definition Classes
    HasCloseContext
  13. def closingTimeout: FiniteDuration
    Attributes
    protected
    Definition Classes
    FlagCloseable → PerformUnlessClosing
  14. def computeTotalLoad: Int
  15. def configuredDomains: Seq[StoredDomainConnectionConfig]

    Returns the domains this sync service is configured with.

  16. def connectDomain(domainAlias: DomainAlias, keepRetrying: Boolean)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Boolean]

    Connect the sync service to the given domain.

    Connect the sync service to the given domain. This method makes sure there can only be one connection in progress at a time.

  17. def containsShutdownTask(token: Long): Boolean
    Definition Classes
    OnShutdownRunner
  18. def currentHealth(): HealthStatus

    Reports the current health of the object.

    Reports the current health of the object. This should always return immediately.

    Definition Classes
    CantonSyncService → ReportsHealth
  19. def currentWriteHealth(): HealthStatus
  20. def disconnectDomain(domain: DomainAlias)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]

    Disconnect the given domain from the sync service.

  21. def disconnectDomains()(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]

    Disconnect from all connected domains.

  22. def domainConnectionConfigByAlias(domainAlias: DomainAlias): EitherT[Future, MissingConfigForAlias, StoredDomainConnectionConfig]
  23. val dynamicDomainParameterGetter: CantonDynamicDomainParameterGetter
  24. val ephemeralHealth: MutableHealthComponent
  25. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  26. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  27. implicit def errorLoggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
    Attributes
    protected
    Definition Classes
    NamedLogging
  28. val eventTranslationStrategy: EventTranslationStrategy
  29. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  30. def getConnectedDomains(request: ConnectedDomainRequest)(implicit traceContext: TraceContext): Future[ConnectedDomainResponse]
    Definition Classes
    CantonSyncService → ReadService
  31. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  32. def incompleteReassignmentOffsets(validAt: LedgerSyncOffset, stakeholders: Set[LfPartyId])(implicit traceContext: TraceContext): Future[Vector[LedgerSyncOffset]]

    Get the offsets of the incomplete assigned/unassigned events for a set of stakeholders.

    Get the offsets of the incomplete assigned/unassigned events for a set of stakeholders.

    validAt

    The offset of validity in participant offset terms.

    stakeholders

    Only offsets are returned which have at least one stakeholder from this set.

    returns

    All the offset of assigned/unassigned events which do not have their conterparts visible at the validAt offset, and only for the reassignments for which this participant is reassigning.

    Definition Classes
    CantonSyncService → ReadService
  33. def incompleteTransferData(validAt: GlobalOffset, stakeholders: Set[LfPartyId])(implicit traceContext: TraceContext): Future[List[IncompleteTransferData]]
  34. def initializeState()(implicit traceContext: TraceContext): Unit
  35. def internalPerformUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): UnlessShutdown[Future[A]]
    Attributes
    protected
    Definition Classes
    PerformUnlessClosing
  36. val isActive: () => Boolean
  37. def isClosing: Boolean

    Check whether we're closing.

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

    Definition Classes
    OnShutdownRunner
  38. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  39. def keepTrackOfOpenFutures: Boolean

    track running futures on shutdown

    track running futures on shutdown

    set to true to get detailed information about all futures that did not complete during shutdown. if set to false, we don't do anything.

    Attributes
    protected
    Definition Classes
    PerformUnlessClosing
  40. def logger: TracedLogger
    Attributes
    protected
    Definition Classes
    NamedLogging
  41. val loggerFactory: NamedLoggerFactory
    Attributes
    protected
    Definition Classes
    CantonSyncService → NamedLogging
  42. def lookupDomainTimeTracker(domainId: DomainId): Option[DomainTimeTracker]

    Lookup a time tracker for the given domainId.

    Lookup a time tracker for the given domainId. A time tracker will only be returned if the domain is registered and connected.

  43. val maxDeduplicationDuration: NonNegativeFiniteDuration
  44. def maxSleepMillis: Long

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

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

    Attributes
    protected
    Definition Classes
    PerformUnlessClosing
  45. def migrateDomain(source: DomainAlias, target: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Unit]
  46. def mkPromise[A](description: String, futureSupervisor: FutureSupervisor, logAfter: Duration = 10.seconds, logLevel: Level = Level.DEBUG)(implicit elc: ErrorLoggingContext, ec: ExecutionContext): PromiseUnlessShutdown[A]

    Use this method to create a PromiseUnlessShutdown that will automatically be cancelled when the close context is closed.

    Use this method to create a PromiseUnlessShutdown that will automatically be cancelled when the close context is closed. This allows proper clean up of stray promises when the node is transitioning to a passive state.

    Note: you should *not* invoke success on the returned promise but rather use trySuccess. The reason is that the call to success may fail in case of shutdown.

    Definition Classes
    PromiseUnlessShutdownFactory
  47. def modifyDomain(config: DomainConnectionConfig)(implicit traceContext: TraceContext): EitherT[Future, SyncServiceError, Unit]

    Modifies the settings of the sync-service's configuration

    Modifies the settings of the sync-service's configuration

    NOTE: This does not automatically reconnect the sync service.

  48. implicit def namedLoggingContext(implicit traceContext: TraceContext): NamedLoggingContext
    Attributes
    protected
    Definition Classes
    NamedLogging
  49. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  50. def noTracingLogger: Logger
    Attributes
    protected
    Definition Classes
    NamedLogging
  51. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  52. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @HotSpotIntrinsicCandidate()
  53. def onCloseFailure(e: Throwable): Unit
    Attributes
    protected
    Definition Classes
    PerformUnlessClosing
  54. def onClosed(): Unit
    Definition Classes
    CantonSyncService → PerformUnlessClosing
  55. final def onFirstClose(): Unit

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

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

    Definition Classes
    PerformUnlessClosing → OnShutdownRunner
    Annotations
    @SuppressWarnings()
  56. val participantId: ParticipantId
  57. def partyHasActiveContracts(partyId: PartyId)(implicit traceContext: TraceContext): Future[Boolean]

    Checks if a given party has any active contracts.

  58. def performUnlessClosing[A](name: String)(f: => A)(implicit traceContext: TraceContext): UnlessShutdown[A]

    Performs the task given by f unless a shutdown has been initiated.

    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.

    f

    The task to perform

    returns

    scala.None$ if a shutdown has been initiated. Otherwise the result of the task.

    Definition Classes
    PerformUnlessClosing
  59. def performUnlessClosingCheckedT[A, N, R](name: String, onClosing: => Checked[A, N, R])(etf: => CheckedT[Future, A, N, R])(implicit ec: ExecutionContext, traceContext: TraceContext): CheckedT[Future, A, N, R]
    Definition Classes
    PerformUnlessClosing
  60. def performUnlessClosingEitherT[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, R]

    Performs the EitherT[Future] given by etf unless a shutdown has been initiated, in which case the provided error is returned instead.

    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.

    etf

    The task to perform

    Definition Classes
    PerformUnlessClosing
  61. def performUnlessClosingEitherTF[E, R](name: String, onClosing: => E)(etf: => EitherT[Future, E, Future[R]])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[Future, E, Future[R]]
    Definition Classes
    PerformUnlessClosing
  62. def performUnlessClosingEitherU[E, R](name: String)(etf: => EitherT[Future, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
    Definition Classes
    PerformUnlessClosing
  63. def performUnlessClosingEitherUSF[E, R](name: String)(etf: => EitherT[FutureUnlessShutdown, E, R])(implicit ec: ExecutionContext, traceContext: TraceContext): EitherT[FutureUnlessShutdown, E, R]
    Definition Classes
    PerformUnlessClosing
  64. def performUnlessClosingF[A](name: String)(f: => Future[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]

    Performs the Future given by f unless a shutdown has been initiated.

    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.

    f

    The task to perform

    returns

    The future completes with com.digitalasset.canton.lifecycle.UnlessShutdown.AbortedDueToShutdown if a shutdown has been initiated. Otherwise the result of the task wrapped in com.digitalasset.canton.lifecycle.UnlessShutdown.Outcome.

    Definition Classes
    PerformUnlessClosing
  65. def performUnlessClosingUSF[A](name: String)(f: => FutureUnlessShutdown[A])(implicit ec: ExecutionContext, traceContext: TraceContext): FutureUnlessShutdown[A]
    Definition Classes
    PerformUnlessClosing
  66. val protocolVersionGetter: (Traced[DomainId]) => Option[ProtocolVersion]
  67. def prune(pruneUpToInclusive: LedgerSyncOffset, submissionId: LedgerSubmissionId, _pruneAllDivulgedContracts: Boolean): CompletionStage[PruningResult]

    Prune the participant ledger specifying the offset up to which participant ledger events can be removed.

    Prune the participant ledger specifying the offset up to which participant ledger events can be removed.

    As this interface applies only to the local participant unlike other administrator services, returns a (completion stage of a) PruningResult rather than a SubmissionResult.

    Ledgers that do not elect to support participant pruning, return NotPruned(Status.UNIMPLEMENTED). Returning an error also keeps the ledger api server from pruning its index.

    Ledgers whose participants hold no participant-local state, but want the ledger api server to prune, return ParticipantPruned.

    For pruning implementations to be fault tolerant, the following aspects are important: - Consider failing a prune request before embarking on destructive operations for example if certain safety conditions are not met (such as being low on resources). This helps minimize the chances of partially performed prune operations. If the system cannot prune up to the specified offset, the call should not alter the system and return NotPruned rather than prune partially. - Implement pruning either atomically (performing all operations or none), or break down pruning steps into idempotent pieces that pick up after retries or system recovery in case of a mid-pruning crash. - To the last point, be aware that pruning of the ledger api server index happens in such an idempotent follow-up step upon successful completion of each prune call. To reach eventual consistency upon failures, be sure to return ParticipantPruned even if the specified offset has already been pruned to allow ledger api server index pruning to proceed in case of an earlier failure.

    pruneUpToInclusive

    The offset up to which contracts should be pruned.

    submissionId

    The submission id.

    returns

    The pruning result.

    Definition Classes
    CantonSyncService → WriteParticipantPruningService
  68. def pruneInternally(pruneUpToInclusive: LedgerSyncOffset)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, CantonError, Unit]
  69. val pruningProcessor: PruningProcessor
  70. def pureCryptoApi: CryptoPureApi

    Returns the pure crypto operations used for the sync protocol

  71. def purgeDomain(domain: DomainAlias): Either[SyncServiceError, Unit]

    Removes a configured and disconnected domain.

    Removes a configured and disconnected domain.

    This is an unsafe operation as it changes the ledger offsets.

  72. def readyDomains: Map[DomainAlias, (DomainId, Boolean)]

    Returns the ready domains this sync service is connected to.

  73. def reconnectDomains(ignoreFailures: Boolean)(implicit traceContext: TraceContext): EitherT[FutureUnlessShutdown, SyncServiceError, Seq[DomainAlias]]

    Reconnect to all configured domains that have autoStart = true

  74. def refreshCaches()(implicit traceContext: TraceContext): FutureUnlessShutdown[Unit]
  75. val repairService: RepairService
  76. def runOnShutdown[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Long

    Same as runOnShutdown_ but returns a token that allows you to remove the task explicitly from being run using cancelShutdownTask

    Same as runOnShutdown_ but returns a token that allows you to remove the task explicitly from being run using cancelShutdownTask

    Definition Classes
    OnShutdownRunner
  77. def runOnShutdown_[T](task: RunOnShutdown)(implicit traceContext: TraceContext): Unit

    Register a task to run when shutdown is initiated.

    Register a task to run when shutdown is initiated.

    You can use this for example to register tasks that cancel long-running computations, whose termination you can then wait for in "closeAsync".

    Definition Classes
    OnShutdownRunner
  78. def runStateChanged(waitingState: Boolean = false): Unit
    Attributes
    protected
    Definition Classes
    OnShutdownRunner
    Annotations
    @VisibleForTesting()
  79. val sequencerClientHealth: MutableHealthComponent
  80. lazy val stateInspection: SyncStateInspection
  81. def stateUpdates(beginAfterOffset: Option[LedgerSyncOffset])(implicit traceContext: TraceContext): Source[(LedgerSyncOffset, Traced[Update]), NotUsed]

    Build source for subscription (for ledger api server indexer).

    Build source for subscription (for ledger api server indexer).

    beginAfterOffset

    offset after which to emit events

    Definition Classes
    CantonSyncService → ReadService
  82. def submitConfiguration(_maxRecordTimeToBeRemovedUpstream: LedgerSyncRecordTime, submissionId: LedgerSubmissionId, config: Configuration)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]

    Submit a new configuration to the ledger.

    Submit a new configuration to the ledger. If the configuration is accepted a com.digitalasset.canton.ledger.participant.state.v2.Update.ConfigurationChanged event will be emitted to all participants. In case of rejection a com.digitalasset.canton.ledger.participant.state.v2.Update.ConfigurationChangeRejected will be emitted.

    The com.digitalasset.canton.ledger.configuration.Configuration contains the identity of the participant that is allowed to further change the configuration. The initial configuration can be submitted by any participant.

    If configuration changes are not supported by the implementation then the com.digitalasset.canton.ledger.participant.state.v2.SubmissionResult.SynchronousError should be returned. *

    returns

    an async result of a SubmissionResult

    Definition Classes
    CantonSyncService → WriteConfigService
  83. def submitReassignment(submitter: Party, applicationId: daml.lf.data.Ref.ApplicationId, commandId: daml.lf.data.Ref.CommandId, submissionId: Option[SubmissionId], workflowId: Option[daml.lf.data.Ref.WorkflowId], reassignmentCommand: ReassignmentCommand)(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]

    Submit a reassignment command for acceptance to the ledger.

    Submit a reassignment command for acceptance to the ledger.

    To complete a reassignment, first a submission of an unassign command followed by an assign command is required. The com.digitalasset.canton.ledger.participant.state.v2.ReassignmentCommand.Assign command must include the unassign ID which can be observed in the accepted event marking the corresponding successful unassign command.

    submitter

    The submitter of the reassignment.

    applicationId

    An identifier for the Daml application that submitted the command. This is used for monitoring, command deduplication, and to allow Daml applications subscribe to their own submissions only.

    commandId

    A submitter-provided identifier to identify an intended ledger change within all the submissions by the same parties and application.

    submissionId

    An identifier for the submission that allows an application to correlate completions to its submissions.

    workflowId

    A submitter-provided identifier used for monitoring and to traffic-shape the work handled by Daml applications communicating over the ledger.

    reassignmentCommand

    The command specifying this reassignment further.

    Definition Classes
    CantonSyncService → WriteService
  84. def submitTransaction(submitterInfo: SubmitterInfo, transactionMeta: TransactionMeta, transaction: LfSubmittedTransaction, _estimatedInterpretationCost: Long, keyResolver: LfKeyResolver, disclosedContracts: ImmArray[ProcessedDisclosedContract])(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]

    Submit a transaction for acceptance to the ledger.

    Submit a transaction for acceptance to the ledger.

    This method must be thread-safe.

    The result of the transaction submission is communicated asynchronously via a com.digitalasset.canton.ledger.participant.state.v2.ReadService implementation backed by the same participant state as this com.digitalasset.canton.ledger.participant.state.v2.WriteService. Successful transaction acceptance is communicated using a com.digitalasset.canton.ledger.participant.state.v2.Update.TransactionAccepted message. Failed transaction acceptance is communicated when possible via a com.digitalasset.canton.ledger.participant.state.v2.Update.CommandRejected message referencing the same submitterInfo as provided in the submission. There can be failure modes where a transaction submission is lost in transit, and no com.digitalasset.canton.ledger.participant.state.v2.Update.CommandRejected is generated. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates for further details.

    A note on ledger time and record time: transactions are submitted together with a ledgerTime provided as part of the transactionMeta information. The ledger time is used by the Daml Engine to resolve calls to the getTime :: Update Time function. Letting the submitter freely choose the ledger time is though a problem for the other stakeholders in the contracts affected by the submitted transaction. The submitter can in principle choose to submit transactions that are effective far in the past or future relative to the wall-clock time of the other participants. This gives the submitter an unfair advantage and make the semantics of getTime quite surprising. We've chosen the following solution to provide useful guarantees for contracts relying on getTime.

    The ledger is charged with (1) associating record-time stamps to accepted transactions and (2) to provide a guarantee on the maximal skew between the ledger effective time and the record time stamp associated to an accepted transaction. The ledger is also expected to provide guarantees on the distribution of the maximal skew between record time stamps on accepted transactions and the wall-clock time at delivery of accepted transactions to a ledger participant. Thereby providing ledger participants with a guarantee on the maximal skew between the ledger effective time of an accepted transaction and the wall-clock time at delivery to these participants.

    Concretely, we typically expect the allowed skew between record time and ledger time to be in the minute range. Thereby leaving ample time for submitting and validating large transactions before they are timestamped with their record time.

    The com.digitalasset.canton.ledger.participant.state.v2.WriteService is responsible for deduplicating commands with the same com.digitalasset.canton.ledger.participant.state.v2.SubmitterInfo.changeId within the com.digitalasset.canton.ledger.participant.state.v2.SubmitterInfo.deduplicationPeriod.

    submitterInfo

    the information provided by the submitter for correlating this submission with its acceptance or rejection on the associated com.digitalasset.canton.ledger.participant.state.v2.ReadService.

    transactionMeta

    the meta-data accessible to all consumers of the transaction. See com.digitalasset.canton.ledger.participant.state.v2.TransactionMeta for more information.

    transaction

    the submitted transaction. This transaction can contain local contract-ids that need suffixing. The participant state may have to suffix those contract-ids in order to guaranteed their global uniqueness. See the Contract Id specification for more detail daml-lf/spec/contract-id.rst.

    Definition Classes
    CantonSyncService → WriteService
  85. def subscribeToConnections(subscriber: ConnectionListener): Unit
  86. val syncCrypto: SyncCryptoApiProvider
  87. val syncDomainHealth: MutableHealthComponent
  88. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  89. def timeouts: ProcessingTimeout
    Attributes
    protected
    Definition Classes
    CantonSyncService → FlagCloseable
  90. def toString(): String
    Definition Classes
    CantonSyncService → AnyRef → Any
  91. implicit val tracer: Tracer
  92. val transferService: TransferService
  93. def uploadPackages(submissionId: LedgerSubmissionId, archives: List[Archive], sourceDescription: Option[String])(implicit traceContext: TraceContext): CompletionStage[SubmissionResult]

    Upload a collection of Daml-LF packages to the ledger.

    Upload a collection of Daml-LF packages to the ledger.

    This method must be thread-safe, not throw, and not block on IO. It is though allowed to perform significant computation.

    Successful archives upload will result in a com.digitalasset.canton.ledger.participant.state.v2.Update.PublicPackageUpload message. See the comments on com.digitalasset.canton.ledger.participant.state.v2.ReadService.stateUpdates and com.digitalasset.canton.ledger.participant.state.v2.Update for further details.

    Note: we accept com.daml.daml_lf_dev.DamlLf.Archives rather than parsed packages, because we want to be able to get the byte size of each individual ArchivePayload, which is information that the read / index service need to provide. Moreover this information should be consistent with the payload that the com.daml.ledger.api.v1.package_service.GetPackageResponse contains. If we were to consume packages we'd have to re-encode them to provide the size, and the size might potentially be different from the original size, which would be quite confusing.

    submissionId

    Submitter chosen submission identifier.

    archives

    Daml-LF archives to be uploaded to the ledger. All archives must be valid, i.e., they must successfully decode and pass Daml engine validation.

    sourceDescription

    Description provided by the backing participant describing where it got the package from, e.g., when, where, or by whom the packages were uploaded.

    returns

    an async result of a com.digitalasset.canton.ledger.participant.state.v2.SubmissionResult

    Definition Classes
    CantonSyncService → WritePackagesService
  94. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  95. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()
  96. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  97. def withNewTrace[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit tracer: Tracer): A
    Attributes
    protected
    Definition Classes
    Spanning
  98. def withSpan[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit traceContext: TraceContext, tracer: Tracer): A
    Attributes
    protected
    Definition Classes
    Spanning
  99. def withSpanFromGrpcContext[A](description: String)(f: (TraceContext) => (SpanWrapper) => A)(implicit tracer: Tracer): A
    Attributes
    protected
    Definition Classes
    Spanning

Deprecated Value Members

  1. def finalize(): Unit
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable]) @Deprecated @Deprecated
    Deprecated

Inherited from HasCloseContext

Inherited from PromiseUnlessShutdownFactory

Inherited from NamedLogging

Inherited from Spanning

Inherited from FlagCloseable

Inherited from PerformUnlessClosing

Inherited from OnShutdownRunner

Inherited from AutoCloseable

Inherited from ReadService

Inherited from WriteService

Inherited from ReportsHealth

Inherited from WriteParticipantPruningService

Inherited from WriteConfigService

Inherited from WritePartyService

Inherited from WritePackagesService

Inherited from AnyRef

Inherited from Any

Ungrouped