class ParticipantPartiesAdministrationGroup extends PartiesAdministrationGroup with FeatureFlagFilter
Linear Supertypes
Ordering
- Alphabetic
- By Inheritance
Inherited
- ParticipantPartiesAdministrationGroup
- FeatureFlagFilter
- NamedLogging
- PartiesAdministrationGroup
- Helpful
- AnyRef
- Any
- Hide All
- Show All
Visibility
- Public
- Protected
Instance Constructors
- new ParticipantPartiesAdministrationGroup(participantId: => ParticipantId, reference: ParticipantReference, consoleEnvironment: ConsoleEnvironment, loggerFactory: NamedLoggerFactory)
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def add_party_async(party: PartyId, synchronizerId: SynchronizerId, sourceParticipant: ParticipantId, serial: PositiveInt, participantPermission: ParticipantPermission): String
- Annotations
- @Summary(s = "Add a previously existing party to the local participant", flag = FeatureFlag.Preview) @Description(s = """Initiate adding a previously existing party to this participant on the specified synchronizer.
|Performs some checks synchronously and then initiates party replication asynchronously. The returned `addPartyRequestId`
|parameter allows identifying asynchronous progress and errors.""")
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def cantonConfig: CantonConfig
- Attributes
- protected
- Definition Classes
- FeatureFlagFilter
- def check[T](flag: FeatureFlag)(command: => T): T
- Attributes
- protected
- Definition Classes
- FeatureFlagFilter
- def clear_party_onboarding_flag(party: PartyId, synchronizerId: SynchronizerId, beginOffsetExclusive: Long, waitForActivationTimeout: Option[NonNegativeFiniteDuration] = Some(
config.NonNegativeFiniteDuration.ofMinutes(2)
)): (Boolean, Option[CantonTimestamp])
- Annotations
- @Summary(s = "Clears the onboarding flag for a party.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Instructs the participant to unilaterally clear the 'onboarding' flag on the
|party-to-participant topology mapping.
|
|This operation is time-sensitive. If run too soon, the flag cannot be safely cleared,
|and another attempt needs to be made.
|
|This endpoint is idempotent and can be safely called multiple times. Polling is
|necessary because the flag can only be cleared after a specific time has passed, and
|the underlying change may take time to become effective.
|
|Prerequisite: A prior party-to-participant mapping topology transaction must exist
|that activates the party on the participant with the onboarding flag set to
|true.
|
|Returns a tuple with the current status:
|- Cleared: (true, None) – The flag is successfully cleared.
|- Pending: (false, Some(timestamp)) – The flag is still set. The timestamp indicates
| the earliest safe time to clear the flag. You may wait until after this
| time to run the command again.
|
|The arguments are:
|- party: The party being onboarded, it must already be active on the participant.
|- synchronizerId: Restricts the party onboarding to the given synchronizer.
|- beginOffsetExclusive: Exclusive ledger offset used as a starting point to find the
| party's activation on the participant.
|- waitForActivationTimeout: The maximum duration the service will wait to find the
| topology transaction that activates the party.
""")
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native()
- val consoleEnvironment: ConsoleEnvironment
- Attributes
- protected
- Definition Classes
- ParticipantPartiesAdministrationGroup → FeatureFlagFilter
- def defaultLimit: PositiveInt
- Attributes
- protected
- Definition Classes
- PartiesAdministrationGroup
- def disable(party: PartyId, forceFlags: ForceFlags = ForceFlags.none, synchronizer: Option[SynchronizerAlias] = None): Unit
- Annotations
- @Summary(s = "Disable party on participant", flag = console.this.Help.Summary.<init>$default$2)
- def enable(name: String, namespace: Namespace = participantId.namespace, synchronizer: Option[SynchronizerAlias] = None, synchronizeParticipants: Seq[ParticipantReference] = consoleEnvironment.participants.all, synchronize: Option[NonNegativeDuration] = Some(
consoleEnvironment.commandTimeouts.unbounded
)): PartyId
- Annotations
- @Summary(s = "Enable/add party to participant", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This function registers a new party on a synchronizer with the current participant within the
|participants namespace. The function fails if the participant does not have appropriate signing keys
|to issue the corresponding PartyToParticipant topology transaction, or if the participant is not connected to any
|synchronizers.
|The synchronizer parameter does not have to be specified if the participant is connected only to one synchronizer.
|If the participant is connected to multiple synchronizers, the party needs to be enabled on each synchronizer explicitly.
|Additionally, a sequence of additional participants can be added to be synchronized to
|ensure that the party is known to these participants as well before the function terminates.
|""")
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef → Any
- implicit def errorLoggingContext(implicit traceContext: TraceContext): ErrorLoggingContext
- Attributes
- protected
- Definition Classes
- NamedLogging
- def export_party_acs(party: PartyId, synchronizerId: SynchronizerId, targetParticipantId: ParticipantId, beginOffsetExclusive: Long, exportFilePath: String = "canton-acs-export.gz", waitForActivationTimeout: Option[NonNegativeFiniteDuration] = Some(
config.NonNegativeFiniteDuration.ofMinutes(2)
), timeout: NonNegativeDuration = timeouts.unbounded): Unit
- Annotations
- @Summary(s = "Export active contracts for a given party to replicate it.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command exports the current Active Contract Set (ACS) for a given
|party to facilitate its replication from a source to a target participant.
|
|It uses the party's most recent activation on the target participant to
|determine the precise historical state of the ACS to export from the
|source participant.
|
|"Activation" on the target participant means the new hosting arrangement
|has been authorized by both the party itself and the target participant
|via party-to-participant topology transactions.
|
|This command will fail if the party has not yet been activated on the
|target participant.
|
|Upon successful completion, the command writes a GZIP-compressed ACS
|snapshot file. This file should then be imported into the target participant's
|ACS using the `import_party_acs` command.
|
|The arguments are:
|- party: The party being replicated, it must already be active on the target participant.
|- synchronizerId: Restricts the export to the given synchronizer.
|- targetParticipantId: Unique identifier of the target participant where the party
| will be replicated.
|- beginOffsetExclusive: Exclusive ledger offset used as starting point fo find the party's
| activation on the target participant.
|- exportFilePath: The path denoting the file where the ACS snapshot will be stored.
|- waitForActivationTimeout: The maximum duration the service will wait to find the topology
| transaction that activates the party on the target participant.
|- timeout: A timeout for this operation to complete.
""")
- def find(filterParty: String): PartyId
- Annotations
- @Summary(s = "Find a party from a filter string", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Will search for all parties that match this filter string. If it finds exactly one party, it
|will return that one. Otherwise, the function will throw.""")
- def find_highest_offset_by_timestamp(synchronizerId: SynchronizerId, timestamp: Instant, force: Boolean = false): Long
- Annotations
- @Summary(s = "Find highest ledger offset by timestamp.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command attempts to find the highest ledger offset among all events belonging
|to a synchronizer that have a record time before or at the given timestamp.
|
|Returns the highest ledger offset, or an error.
|
|Possible failure causes:
|- The requested timestamp is too far in the past for which no events exist anymore.
|- There are no events for the given synchronizer.
|- Not all events have been processed fully and/or published to the Ledger API DB
| until the requested timestamp.
|
|Depending on the failure cause, this command can be tried to get a ledger offset.
|For example, if not all events have been processed fully and/or published to the
|Ledger API DB, a retry makes sense.
|
|The arguments are:
|- synchronizerId: Restricts the query to a particular synchronizer.
|- timestamp: A point in time.
|- force: Defaults to false. If true, returns the highest currently known ledger offset
| with a record time before or at the given timestamp.
|""")
- def find_party_max_activation_offset(partyId: PartyId, participantId: ParticipantId, synchronizerId: SynchronizerId, validFrom: Option[Instant] = None, beginOffsetExclusive: Long = 0L, endOffsetInclusive: Option[Long] = None, completeAfter: PositiveInt = PositiveInt.MaxValue, timeout: NonNegativeDuration = timeouts.bounded): Long
- Annotations
- @Summary(s = "Finds a party's highest activation offset.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command locates the highest ledger offset where a party's activation matches
|specified criteria.
|
|It searches the ledger for topology transactions, sequenced by the given synchronizer
|(`synchronizerId`), that result in the party (`partyId`) being newly hosted on the
|participant (`participantId`). An optional `validFrom` timestamp filters the topology
|transactions for their effective time.
|
|The ledger search occurs within the specified offset range, targeting a specific number
|of topology transactions (`completeAfter`).
|
|The search begins at the ledger start if `beginOffsetExclusive` is default. If the
|participant was pruned and `beginOffsetExclusive` is below the pruning offset, a
|`NOT_FOUND` error occurs. Use an `beginOffsetExclusive` near, but before, the desired
|topology transactions.
|
|If `endOffsetInclusive` is not set (`None`), the search continues until `completeAfter`
|number of transactions are found or the `timeout` expires. Otherwise, the ledger search
|ends at the specified offset.
|
|This command is useful for creating ACS snapshots with `export_acs`, which requires the
|party activation ledger offset.
|
|
|The arguments are:
|- partyId: The party to find activations for.
|- participantId: The participant hosting the new party.
|- synchronizerId: The synchronizer sequencing the activations.
|- validFrom: The activation's effective time (default: None).
|- beginOffsetExclusive: Starting ledger offset (default: 0).
|- endOffsetInclusive: Ending ledger offset (default: None = trailing search).
|- completeAfter: Number of transactions to find (default: Maximum = no limit).
|- timeout: Search timeout (default: 1 minute).
|""")
- def find_party_max_deactivation_offset(partyId: PartyId, participantId: ParticipantId, synchronizerId: SynchronizerId, validFrom: Option[Instant] = None, beginOffsetExclusive: Long = 0L, endOffsetInclusive: Option[Long] = None, completeAfter: PositiveInt = PositiveInt.MaxValue, timeout: NonNegativeDuration = timeouts.bounded): Long
- Annotations
- @Summary(s = "Finds a party's highest deactivation offset.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command locates the highest ledger offset where a party's deactivation matches
|specified criteria.
|
|It searches the ledger for topology transactions, sequenced by the given synchronizer
|(`synchronizerId`), that result in the party (`partyId`) being revoked on the participant
|(`participantId`). An optional `validFrom` timestamp filters the topology transactions
|for their effective time.
|
|The ledger search occurs within the specified offset range, targeting a specific number
|of topology transactions (`completeAfter`).
|
|The search begins at the ledger start if `beginOffsetExclusive` is default. If the
|participant was pruned and `beginOffsetExclusive` is below the pruning offset, a
|`NOT_FOUND` error occurs. Use an `beginOffsetExclusive` near, but before, the desired
|topology transactions.
|
|If `endOffsetInclusive` is not set (`None`), the search continues until `completeAfter`
|number of transactions are found or the `timeout` expires. Otherwise, the ledger search
|ends at the specified offset.
|
|This command is useful for finding active contracts at the ledger offset where a party
|has been off-boarded from a participant.
|
|
|The arguments are:
|- partyId: The party to find deactivations for.
|- participantId: The participant hosting the new party.
|- synchronizerId: The synchronizer sequencing the deactivations.
|- validFrom: The deactivation's effective time (default: None).
|- beginOffsetExclusive: Starting ledger offset (default: 0).
|- endOffsetInclusive: Ending ledger offset (default: None = trailing search).
|- completeAfter: Number of transactions to find (default: Maximum = no limit).
|- timeout: Search timeout (default: 1 minute).
|""")
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def get_add_party_status(addPartyRequestId: String): AddPartyStatus
- Annotations
- @Summary(s = "Obtain status on a pending `add_party_async` call", flag = FeatureFlag.Preview) @Description(s = """Retrieve status information on a party previously added via the `add_party_async` endpoint
|by specifying the previously returned `addPartyRequestId` parameter.""")
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native()
- def help(methodName: String)(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- Annotations
- @Summary(s = "Help for specific commands (use help() or help(\"method\") for more information)", flag = console.this.Help.Summary.<init>$default$2) @Topic(t = Seq("Top-level Commands"))
- def help()(implicit consoleEnvironment: ConsoleEnvironment): Unit
- Definition Classes
- Helpful
- def hosted(filterParty: String = "", synchronizerIds: Set[SynchronizerId] = Set.empty, asOf: Option[Instant] = None, limit: PositiveInt = defaultLimit): Seq[ListPartiesResult]
- Annotations
- @Summary(s = "List parties hosted by this participant", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Inspect the parties hosted by this participant as used for synchronisation.
|The response is built from the timestamped topology transactions of each synchronizer, excluding the
|authorized store of the given node. The search will include all hosted parties and is equivalent
|to running the `list` method using the participant id of the invoking participant.
|
filterParty: Filter by parties starting with the given string.
filterSynchronizerId: Filter by synchronizers whose id starts with the given string.
asOf: Optional timestamp to inspect the topology state at a given point in time.
limit: How many items to return (defaults to canton.parameters.console.default-limit)
Example: participant1.parties.hosted(filterParty="alice")""")
- def import_party_acs(importFilePath: String = "canton-acs-export.gz", workflowIdPrefix: String = "", contractImportMode: ContractImportMode = ContractImportMode.Validation, representativePackageIdOverride: RepresentativePackageIdOverride = RepresentativePackageIdOverride.NoOverride): Unit
- Annotations
- @Summary(s = "Import active contracts from a snapshot file to replicate a party.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """This command imports contracts from an Active Contract Set (ACS) snapshot
|file into the participant's ACS. It expects the given ACS snapshot file to
|be the result of a previous `export_party_acs` command invocation.
|
|The argument is:
|- importFilePath: The path denoting the file from where the ACS snapshot will be read.
| Defaults to "canton-acs-export.gz" when undefined.
|- workflowIdPrefix: Sets a custom prefix for the workflow ID to easily identify all
| transactions generated by this import.
| Defaults to "import-<random_UUID>" when unspecified.
|- contractImportMode: Governs contract authentication processing on import. Options include
| Validation (default), [Accept].
|- representativePackageIdOverride: Defines override mappings for assigning
| representative package IDs to contracts upon ACS import.
| Defaults to NoOverride when undefined.
""")
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def list(filterParty: String = "", filterParticipant: String = "", synchronizerIds: Set[SynchronizerId] = Set.empty, asOf: Option[Instant] = None, limit: PositiveInt = defaultLimit): Seq[ListPartiesResult]
- Definition Classes
- PartiesAdministrationGroup
- Annotations
- @Summary(s = "List active parties, their active participants, and the participants' permissions on synchronizers.", flag = console.this.Help.Summary.<init>$default$2) @Description(s = """Inspect the parties known by this participant as used for synchronisation.
|The response is built from the timestamped topology transactions of each synchronizer, excluding the
|authorized store of the given node. For each known party, the list of active
|participants and their permission on the synchronizer for that party is given.
|
filterParty: Filter by parties starting with the given string.
filterParticipant: Filter for parties that are hosted by a participant with an id starting with the given string
filterSynchronizerId: Filter by synchronizers whose id starts with the given string.
asOf: Optional timestamp to inspect the topology state at a given point in time.
limit: Limit on the number of parties fetched (defaults to canton.parameters.console.default-limit).
Example: participant1.parties.list(filterParty="alice")
""")
- def logger: TracedLogger
- Attributes
- protected
- Definition Classes
- NamedLogging
- val loggerFactory: NamedLoggerFactory
- Attributes
- protected
- Definition Classes
- ParticipantPartiesAdministrationGroup → NamedLogging
- implicit def namedLoggingContext(implicit traceContext: TraceContext): NamedLoggingContext
- Attributes
- protected
- Definition Classes
- NamedLogging
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def noTracingLogger: Logger
- Attributes
- protected
- Definition Classes
- NamedLogging
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native()
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toString(): String
- Definition Classes
- AnyRef → Any
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()