Type Members

1.  sealed abstract class AddRemoveChangeOp extends TopologyChangeOp

   +/-

2.  final case class AuthorityOfX(partyId: PartyId, domainId: Option[DomainId], threshold: PositiveInt, parties: Seq[PartyId]) extends TopologyMappingX with Product with Serializable
3.  final case class DomainGovernanceElement(mapping: DomainGovernanceMapping) extends TopologyStateElement[DomainGovernanceMapping] with Product with Serializable
4.  sealed trait DomainGovernanceMapping extends TopologyMapping
5.  final case class DomainGovernanceTransaction extends TopologyTransaction[Replace] with Product with Serializable
6.  final case class DomainParametersChange(domainId: DomainId, domainParameters: DynamicDomainParameters) extends DomainGovernanceMapping with Product with Serializable
7.  final case class DomainParametersStateX(domain: DomainId, parameters: DynamicDomainParameters) extends TopologyMappingX with Product with Serializable

   Dynamic domain parameter settings for the domain

   Dynamic domain parameter settings for the domain

   Each domain has a set of parameters that can be changed at runtime. These changes are authorized by the owner of the domain and distributed to all nodes accordingly.

8.  sealed case class DomainTopologyTransactionType extends Product with Serializable
9.  final case class DomainTrustCertificateX(participantId: ParticipantId, domainId: DomainId, transferOnlyToGivenTargetDomains: Boolean, targetDomains: Seq[DomainId]) extends TopologyMappingX with Product with Serializable

   Participant domain trust certificate

10.  final case class HostingParticipant(participantId: ParticipantId, permission: ParticipantPermissionX) extends Product with Serializable
11.  final case class IdentifierDelegation(identifier: UniqueIdentifier, target: SigningPublicKey) extends TopologyStateUpdateMapping with Product with Serializable

    An identifier delegation

    An identifier delegation

    entrusts a public-key to do any change with respect to the identifier {(X,I) => p_k}

12.  final case class IdentifierDelegationX(identifier: UniqueIdentifier, target: SigningPublicKey) extends TopologyMappingX with Product with Serializable

    An identifier delegation

    An identifier delegation

    entrusts a public-key to do any change with respect to the identifier {(X,I) => p_k}

13.  final case class LegalIdentityClaim extends ProtocolVersionedMemoizedEvidence with HasProtocolVersionedWrapper[LegalIdentityClaim] with Product with Serializable
14.  sealed trait LegalIdentityClaimEvidence extends AnyRef
15.  final case class MediatorDomainState(side: RequestSide, domain: DomainId, mediator: MediatorId) extends TopologyStateUpdateMapping with Product with Serializable
16.  final case class MediatorDomainStateX extends TopologyMappingX with Product with Serializable

    Mediator definition for a domain

    Mediator definition for a domain

    Each domain needs at least one mediator (group), but can have multiple. Mediators can be temporarily be turned off by making them observers. This way, they get informed but they don't have to reply.

17.  final case class NamespaceDelegation(namespace: Namespace, target: SigningPublicKey, isRootDelegation: Boolean) extends TopologyStateUpdateMapping with Product with Serializable

    A namespace delegation transaction (intermediate CA)

    A namespace delegation transaction (intermediate CA)

    Entrusts a public-key to perform changes on the namespace {(*,I) => p_k}

    If the delegation is a root delegation, then the target key inherits the right to authorize other NamespaceDelegations.

18.  final case class NamespaceDelegationX extends TopologyMappingX with Product with Serializable

    A namespace delegation transaction (intermediate CA)

    A namespace delegation transaction (intermediate CA)

    Entrusts a public-key to perform changes on the namespace {(*,I) => p_k}

    If the delegation is a root delegation, then the target key inherits the right to authorize other NamespaceDelegations.

19.  final case class OwnerToKeyMapping(owner: KeyOwner, key: PublicKey) extends TopologyStateUpdateMapping with Product with Serializable

    A key owner (participant, mediator, sequencer, manager) to key mapping

    A key owner (participant, mediator, sequencer, manager) to key mapping

    In Canton, we need to know keys for all participating entities. The entities are all the protocol members (participant, mediator, topology manager) plus the sequencer (which provides the communication infrastructure for the members).

20.  final case class OwnerToKeyMappingX(member: Member, domain: Option[DomainId], keys: NonEmpty[Seq[PublicKey]]) extends TopologyMappingX with Product with Serializable

    A key owner (participant, mediator, sequencer) to key mapping

    A key owner (participant, mediator, sequencer) to key mapping

    In Canton, we need to know keys for all participating entities. The entities are all the protocol members (participant, mediator) plus the sequencer (which provides the communication infrastructure for the protocol members).

21.  final case class ParticipantAttributes(permission: ParticipantPermission, trustLevel: TrustLevel) extends Product with Serializable

    If trustLevel is TrustLevel.Vip, then permission.canConfirm must hold.

22.  final case class ParticipantDomainLimits(maxRate: Int, maxNumParties: Int, maxNumPackages: Int) extends Product with Serializable
23.  final case class ParticipantDomainPermissionX(domainId: DomainId, participantId: ParticipantId, permission: ParticipantPermissionX, trustLevel: TrustLevelX, limits: Option[ParticipantDomainLimits], loginAfter: Option[CantonTimestamp]) extends TopologyMappingX with Product with Serializable
24.  sealed trait ParticipantPermission extends Product with Serializable

    Permissions of a participant, i.e., things a participant can do on behalf of a party

    Permissions of a participant, i.e., things a participant can do on behalf of a party

    Permissions are hierarchical. A participant who can submit can confirm. A participant who can confirm can observe.

25.  sealed trait ParticipantPermissionX extends Product with Serializable
26.  final case class ParticipantState(side: RequestSide, domain: DomainId, participant: ParticipantId, permission: ParticipantPermission, trustLevel: TrustLevel) extends TopologyStateUpdateMapping with Product with Serializable
27.  final case class PartyHostingLimitsX(domainId: DomainId, partyId: PartyId, quota: Int) extends TopologyMappingX with Product with Serializable
28.  final case class PartyToParticipant(side: RequestSide, party: PartyId, participant: ParticipantId, permission: ParticipantPermission) extends TopologyStateUpdateMapping with Product with Serializable

    party to participant mapping

    party to participant mapping

    We can map a party to several participants at the same time. We represent such a mapping in the topology state using the party to participant

29.  final case class PartyToParticipantX(partyId: PartyId, domainId: Option[DomainId], threshold: PositiveInt, participants: Seq[HostingParticipant], groupAddressing: Boolean) extends TopologyMappingX with Product with Serializable
30.  final case class PurgeTopologyTransactionX extends TopologyMappingX with Product with Serializable
31.  sealed trait RequestSide extends AnyRef

    Side of the party to participant mapping request

    Side of the party to participant mapping request

    Party to participant mapping request need to be approved by both namespaces if the namespaces are different. We support this by allowing to split the signatures into two transactions (so both namespace controller sign the same transaction, just with different "RequestSide"

    {Both, +, (P,I) -> (N,J)}^{[s_I, s_J] = {From,+, (P,I) -> (N,J)}}[s_I] + {To,+, (P,I) -> (N,J)}^[s_J]

32.  sealed trait RequiredAuth extends AnyRef

    Defines the required authorization chain

33.  final case class SequencerDomainStateX extends TopologyMappingX with Product with Serializable

    which sequencers are active on the given domain

    which sequencers are active on the given domain

    authorization: whoever controls the domain and all the owners of the active or observing sequencers that were not already present in the tx with serial = n - 1 exception: a sequencer can leave the consortium unilaterally as long as there are enough members to reach the threshold UNIQUE(domain)

34.  final case class SignedLegalIdentityClaim(uid: UniqueIdentifier, claim: ByteString, signature: Signature) extends TopologyStateUpdateMapping with PrettyPrinting with Product with Serializable
35.  case class SignedTopologyTransaction[+Op <: TopologyChangeOp](transaction: TopologyTransaction[Op], key: SigningPublicKey, signature: Signature)(representativeProtocolVersion: RepresentativeProtocolVersion[SignedTopologyTransaction.type], deserializedFrom: Option[ByteString] = None) extends HasProtocolVersionedWrapper[SignedTopologyTransaction[TopologyChangeOp]] with ProtocolVersionedMemoizedEvidence with Product with Serializable with PrettyPrinting

    A signed topology transaction

    A signed topology transaction

    Every topology transaction needs to be authorized by an appropriate key. This object represents such an authorization, where there is a signature of a given key of the given topology transaction.

    Whether the key is eligible to authorize the topology transaction depends on the topology state

    Annotations

    @SuppressWarnings()

36.  final case class SignedTopologyTransactionX[+Op <: TopologyChangeOpX, +M <: TopologyMappingX](transaction: TopologyTransactionX[Op, M], signatures: NonEmpty[Set[Signature]], isProposal: Boolean)(representativeProtocolVersion: RepresentativeProtocolVersion[SignedTopologyTransactionX.type]) extends HasProtocolVersionedWrapper[SignedTopologyTransactionX[TopologyChangeOpX, TopologyMappingX]] with Product with Serializable with PrettyPrinting

    A signed topology transaction

    A signed topology transaction

    Every topology transaction needs to be authorized by an appropriate key. This object represents such an authorization, where there is a signature of a given key of the given topology transaction.

    Whether the key is eligible to authorize the topology transaction depends on the topology state

37.  sealed trait TopologyChangeOp extends TopologyChangeOpCommon

    Add, Remove, Replace

38.  trait TopologyChangeOpCommon extends Product with Serializable with PrettyPrinting
39.  sealed trait TopologyChangeOpX extends TopologyChangeOpCommon

    Replace or Remove

40.  final case class TopologyElementId(str: String255) extends LengthLimitedStringWrapper with PrettyPrinting with Product with Serializable

    Topology transaction id

    Topology transaction id

    Used to distinguish topology transactions from each other such that a Remove explicitly refers to a corresponding Add, such that we can support re-addition (Add, Remove, Add again).

41.  sealed trait TopologyMapping extends Product with Serializable with PrettyPrinting

    X -> Y

42.  sealed trait TopologyMappingX extends Product with Serializable with PrettyPrinting
43.  sealed trait TopologyStateElement[+M <: TopologyMapping] extends PrettyPrinting
44.  final case class TopologyStateUpdate[+Op <: AddRemoveChangeOp] extends TopologyTransaction[Op] with Product with Serializable

    +/-, X -> Y

    +/-, X -> Y

    Every topology transaction is the combination of an operation (Add, Remove), a unique element id and the state operation.

    An Add can pick a random element id. A remove needs to pick the element id of the corresponding addition. Element ids are uniqueness constraints. Once removed, they can't be re-added (during a configurable time window)

45.  final case class TopologyStateUpdateElement(id: TopologyElementId, mapping: TopologyStateUpdateMapping) extends TopologyStateElement[TopologyStateUpdateMapping] with Product with Serializable
46.  sealed trait TopologyStateUpdateMapping extends TopologyMapping
47.  sealed trait TopologyTransaction[+Op <: TopologyChangeOp] extends ProtocolVersionedMemoizedEvidence with PrettyPrinting with HasProtocolVersionedWrapper[TopologyTransaction[TopologyChangeOp]] with Product with Serializable
48.  final case class TopologyTransactionX[+Op <: TopologyChangeOpX, +M <: TopologyMappingX] extends ProtocolVersionedMemoizedEvidence with PrettyPrinting with HasProtocolVersionedWrapper[TopologyTransactionX[TopologyChangeOpX, TopologyMappingX]] with Product with Serializable

    Change to the distributed domain topology

    Change to the distributed domain topology

    A topology transaction is a state change to the domain topology. There are different types of topology states (so called mappings, because they map some id to some value).

    Each mapping has some variables and some combination of these variables makes a "unique key". Subsequent changes to that key need to have an incremental serial number.

    Topology changes always affect certain identities. Therefore, these topology transactions need to be authorized through signatures.

    An authorized transaction is called a SignedTopologyTransactionX

49.  final case class TrafficControlStateX extends TopologyMappingX with Product with Serializable
50.  sealed trait TrustLevel extends Product with Serializable with PrettyPrinting

    The trust level of the participant.

    The trust level of the participant. Can be either Ordinary or Vip

51.  sealed trait TrustLevelX extends AnyRef
52.  final case class UnionspaceDefinitionX extends TopologyMappingX with Product with Serializable

    which sequencers are active on the given domain

    which sequencers are active on the given domain

    authorization: whoever controls the domain and all the owners of the active or observing sequencers that were not already present in the tx with serial = n - 1 exception: a sequencer can leave the consortium unilaterally as long as there are enough members to reach the threshold

53.  trait UniquePath extends AnyRef

    Unique path of a topology transaction

    Unique path of a topology transaction

    The unique path allows us to distinguish any topology transaction by a unique code. In addition, the code is chosen such that we can organise all transactions in a binary tree structure such that changes to that tree are mostly local.

    The path is defined by namespace :: Rest and Rest can be "nsd" :: content :: topologyElementId (for namespace delegations) "uid" :: uid.identifier :: "code" :: element-id

    (type, namespace, optional[identifier], optional[element-id])

    Therefore, if we onboard a new participant with many parties, all the changes to the topology will be within the "subpath" defined by the namespace.

54.  final case class UniquePathNamespaceDelegation(namespace: Namespace, elementId: TopologyElementId) extends UniquePath with Product with Serializable
55.  final case class UniquePathSignedDomainGovernanceTransaction(uid: UniqueIdentifier, dbType: DomainTopologyTransactionType) extends UniquePath with Product with Serializable
56.  final case class UniquePathSignedTopologyTransaction(uid: UniqueIdentifier, dbType: DomainTopologyTransactionType, elementId: TopologyElementId) extends UniquePath with Product with Serializable
57.  final case class VettedPackages(participant: ParticipantId, packageIds: Seq[LfPackageId]) extends TopologyStateUpdateMapping with PrettyPrinting with Product with Serializable
58.  final case class VettedPackagesX(participantId: ParticipantId, domainId: Option[DomainId], packageIds: Seq[LfPackageId]) extends TopologyMappingX with Product with Serializable