Type Members

1.  trait ActionNodeInfo extends AnyRef

   Trait for extracting information from an abstract action node.

   Trait for extracting information from an abstract action node. Used for sharing the implementation of common computations over nodes and transactions.

   External codebases use these utilities on transaction and node implementations that are not the one defined by ActionNode and hence the need for the indirection.

2.  final case class BlindingInfo(disclosure: Relation[NodeId, Party], divulgence: Relation[ContractId, Party]) extends Product with Serializable

   A transaction's blinding information, consisting of disclosure and divulgence info.

   A transaction's blinding information, consisting of disclosure and divulgence info.

   "Disclosure" tells us which transaction nodes to communicate to which parties. See https://docs.daml.com/concepts/ledger-model/ledger-privacy.html Note that rollback nodes are a bit special here: Even if the node itself is not disclosed, a party will be disclosed if a node was below a rollback node. That information is not included in blinding info at this point.

   "Divulgence" tells us which contracts to communicate to which parties so that their participant nodes can perform post-commit validation. Note that divulgence can also divulge e.g. contract IDs that were created _outside_ this transaction. See also https://docs.daml.com/concepts/ledger-model/ledger-privacy.html#divulgence-when-non-stakeholders-see-contracts

   disclosure

   Disclosure, specified in terms of local transaction node IDs Each node in the transaction will be mapped to a non-empty set of witnesses for ledger API transactions. Scenarios unfortunately break this invariant and we can have rollback nodes at the top with an empty set of witnesses. We still include those in the map here.

   divulgence

   Divulgence, specified in terms of contract IDs. Note that if this info was produced by blinding a transaction containing only contract ids, this map may also contain contracts produced in the same transaction. We only include contracts that are divulged to a non-empty set of parties since there is no difference between not divulging a contract and divulging it to no one.

3.  type CommittedTransaction = T
4.  sealed trait ContractKeyUniquenessMode extends AnyRef

   Controls whether the engine should error out when it encounters duplicate keys.

   Controls whether the engine should error out when it encounters duplicate keys. This is always turned on with the exception of Canton which allows turning this on or off and forces it to be turned off in multi-domain mode.

5.  sealed abstract class DiscriminatedSubtype[X] extends AnyRef
6.  final class GlobalKey extends AnyRef

   Useful in various circumstances -- basically this is what a ledger implementation must use as a key.

   Useful in various circumstances -- basically this is what a ledger implementation must use as a key. The 'hash' is guaranteed to be stable over time.

7.  final case class GlobalKeyWithMaintainers(globalKey: GlobalKey, maintainers: Set[Party]) extends Product with Serializable
8.  sealed abstract class HasTxNodes extends AnyRef
9.  final case class IncompleteTransaction(transaction: Transaction, locationInfo: Map[NodeId, Location]) extends Product with Serializable
10.  sealed abstract class Node extends Product with Serializable with CidContainer[Node]

    Generic transaction node type for both update transactions and the transaction graph.

11.  final case class NodeId(index: Int) extends Product with Serializable
12.  class Normalization extends AnyRef
13.  final case class ReplayMismatch(recordedTransaction: VersionedTransaction, replayedTransaction: VersionedTransaction) extends Product with Serializable
14.  type SubmittedTransaction = T
15.  final case class Transaction(nodes: Map[NodeId, Node], roots: ImmArray[NodeId]) extends HasTxNodes with CidContainer[Transaction] with Product with Serializable

    General transaction type

    General transaction type

    Abstracts over NodeId type and ContractId type ContractId restricts the occurrence of contractIds

    nodes

    The nodes of this transaction.

    roots

    References to the root nodes of the transaction. Users of this class may assume that all instances are well-formed, i.e., isWellFormed.isEmpty. For performance reasons, users are not required to call isWellFormed. Therefore, it is forbidden to create ill-formed instances, i.e., instances with !isWellFormed.isEmpty.

16.  final case class TransactionNodeStatistics(committed: Actions, rolledBack: Actions) extends Product with Serializable
17.  sealed abstract class TransactionVersion extends Product with Serializable
18.  case class Versioned[+X](version: TransactionVersion, unversioned: X) extends Product with Serializable
19.  final case class VersionedTransaction extends HasTxNodes with CidContainer[VersionedTransaction] with NoCopy with Product with Serializable