package transaction
- Alphabetic
- Public
- Protected
Type Members
- sealed abstract class AddRemoveChangeOp extends TopologyChangeOp
+/-
- final case class AuthorityOfX(partyId: PartyId, domainId: Option[DomainId], threshold: PositiveInt, parties: Seq[PartyId]) extends TopologyMappingX with Product with Serializable
- final case class DomainGovernanceElement(mapping: DomainGovernanceMapping) extends TopologyStateElement[DomainGovernanceMapping] with Product with Serializable
- sealed trait DomainGovernanceMapping extends TopologyMapping
- final case class DomainGovernanceTransaction extends TopologyTransaction[Replace] with Product with Serializable
- final case class DomainParametersChange(domainId: DomainId, domainParameters: DynamicDomainParameters) extends DomainGovernanceMapping with Product with Serializable
- 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.
- sealed case class DomainTopologyTransactionType extends Product with Serializable
- final case class DomainTrustCertificateX(participantId: ParticipantId, domainId: DomainId, transferOnlyToGivenTargetDomains: Boolean, targetDomains: Seq[DomainId]) extends TopologyMappingX with Product with Serializable
Participant domain trust certificate
- final case class HostingParticipant(participantId: ParticipantId, permission: ParticipantPermissionX) extends Product with Serializable
- 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}
- 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}
- final case class LegalIdentityClaim extends ProtocolVersionedMemoizedEvidence with HasProtocolVersionedWrapper[LegalIdentityClaim] with Product with Serializable
- sealed trait LegalIdentityClaimEvidence extends AnyRef
- final case class MediatorDomainState(side: RequestSide, domain: DomainId, mediator: MediatorId) extends TopologyStateUpdateMapping with Product with Serializable
- 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.
- 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.
- 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.
- 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).
- 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).
- final case class ParticipantAttributes(permission: ParticipantPermission, trustLevel: TrustLevel) extends Product with Serializable
If trustLevel is TrustLevel.Vip, then permission
.
canConfirm must hold. - final case class ParticipantDomainLimits(maxRate: Int, maxNumParties: Int, maxNumPackages: Int) extends Product with Serializable
- final case class ParticipantDomainPermissionX(domainId: DomainId, participantId: ParticipantId, permission: ParticipantPermissionX, trustLevel: TrustLevelX, limits: Option[ParticipantDomainLimits], loginAfter: Option[CantonTimestamp]) extends TopologyMappingX with Product with Serializable
- 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.
- sealed trait ParticipantPermissionX extends Product with Serializable
- final case class ParticipantState(side: RequestSide, domain: DomainId, participant: ParticipantId, permission: ParticipantPermission, trustLevel: TrustLevel) extends TopologyStateUpdateMapping with Product with Serializable
- final case class PartyHostingLimitsX(domainId: DomainId, partyId: PartyId, quota: Int) extends TopologyMappingX with Product with Serializable
- 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
- final case class PartyToParticipantX(partyId: PartyId, domainId: Option[DomainId], threshold: PositiveInt, participants: Seq[HostingParticipant], groupAddressing: Boolean) extends TopologyMappingX with Product with Serializable
- final case class PurgeTopologyTransactionX extends TopologyMappingX with Product with Serializable
- 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]
- sealed trait RequiredAuth extends AnyRef
Defines the required authorization chain
- 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)
- final case class SignedLegalIdentityClaim(uid: UniqueIdentifier, claim: ByteString, signature: Signature) extends TopologyStateUpdateMapping with PrettyPrinting with Product with Serializable
- 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()
- 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
- sealed trait TopologyChangeOp extends TopologyChangeOpCommon
Add, Remove, Replace
- trait TopologyChangeOpCommon extends Product with Serializable with PrettyPrinting
- sealed trait TopologyChangeOpX extends TopologyChangeOpCommon
Replace or Remove
- 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).
- sealed trait TopologyMapping extends Product with Serializable with PrettyPrinting
X -> Y
- sealed trait TopologyMappingX extends Product with Serializable with PrettyPrinting
- sealed trait TopologyStateElement[+M <: TopologyMapping] extends PrettyPrinting
- 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)
- final case class TopologyStateUpdateElement(id: TopologyElementId, mapping: TopologyStateUpdateMapping) extends TopologyStateElement[TopologyStateUpdateMapping] with Product with Serializable
- sealed trait TopologyStateUpdateMapping extends TopologyMapping
- sealed trait TopologyTransaction[+Op <: TopologyChangeOp] extends ProtocolVersionedMemoizedEvidence with PrettyPrinting with HasProtocolVersionedWrapper[TopologyTransaction[TopologyChangeOp]] with Product with Serializable
- 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
- final case class TrafficControlStateX extends TopologyMappingX with Product with Serializable
- 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
- sealed trait TrustLevelX extends AnyRef
- 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
- 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.
- final case class UniquePathNamespaceDelegation(namespace: Namespace, elementId: TopologyElementId) extends UniquePath with Product with Serializable
- final case class UniquePathSignedDomainGovernanceTransaction(uid: UniqueIdentifier, dbType: DomainTopologyTransactionType) extends UniquePath with Product with Serializable
- final case class UniquePathSignedTopologyTransaction(uid: UniqueIdentifier, dbType: DomainTopologyTransactionType, elementId: TopologyElementId) extends UniquePath with Product with Serializable
- final case class VettedPackages(participant: ParticipantId, packageIds: Seq[LfPackageId]) extends TopologyStateUpdateMapping with PrettyPrinting with Product with Serializable
- final case class VettedPackagesX(participantId: ParticipantId, domainId: Option[DomainId], packageIds: Seq[LfPackageId]) extends TopologyMappingX with Product with Serializable
Value Members
- object AddRemoveChangeOp extends Serializable
- object AuthorityOfX extends Serializable
- object DomainGovernanceTransaction extends Serializable
- object DomainParametersChange extends Serializable
- object DomainParametersStateX extends Serializable
- object DomainTopologyTransactionType extends Serializable
- object DomainTrustCertificateX extends Serializable
- object HostingParticipant extends Serializable
- object IdentifierDelegation extends Serializable
- object IdentifierDelegationX extends Serializable
- object LegalIdentityClaim extends HasMemoizedProtocolVersionedWrapperCompanion[LegalIdentityClaim]
- object LegalIdentityClaimEvidence
- object MediatorDomainState extends Serializable
- object MediatorDomainStateX extends Serializable
- object NamespaceDelegation extends Serializable
- object NamespaceDelegationX extends Serializable
- object OwnerToKeyMapping extends Serializable
- object OwnerToKeyMappingX extends Serializable
- object ParticipantDomainLimits extends Serializable
- object ParticipantDomainPermissionX extends Serializable
- object ParticipantPermission extends Serializable
- object ParticipantPermissionX extends Serializable
- object ParticipantState extends Serializable
- object PartyHostingLimitsX extends Serializable
- object PartyToParticipant extends Serializable
- object PartyToParticipantX extends Serializable
- object PurgeTopologyTransactionX extends Serializable
- object RequestSide
- object RequiredAuth
- object SequencerDomainStateX extends Serializable
- object SignedLegalIdentityClaim extends Serializable
- object SignedTopologyTransaction extends HasMemoizedProtocolVersionedWrapperCompanion[SignedTopologyTransaction[TopologyChangeOp]]
- object SignedTopologyTransactionX extends HasProtocolVersionedCompanion[SignedTopologyTransactionX[TopologyChangeOpX, TopologyMappingX]]
- object TopologyChangeOp extends Serializable
- object TopologyChangeOpX extends Serializable
- object TopologyElementId extends LengthLimitedStringWrapperCompanion[String255, TopologyElementId] with Serializable
- object TopologyMappingX extends Serializable
- object TopologyStateUpdate extends Serializable
- object TopologyTransaction extends HasMemoizedProtocolVersionedWrapperCompanion[TopologyTransaction[TopologyChangeOp]]
- object TopologyTransactionX extends HasMemoizedProtocolVersionedWrapperCompanion[TopologyTransactionX[TopologyChangeOpX, TopologyMappingX]]
- object TrafficControlStateX extends Serializable
- object TrustLevel extends Serializable
- object TrustLevelX
- object UnionspaceDefinitionX extends Serializable
- object UniquePath
- object UniquePathSignedTopologyTransaction extends Serializable
- object VettedPackages extends Serializable
- object VettedPackagesX extends Serializable