final case class Transaction(nodes: Map[NodeId, Node], roots: ImmArray[NodeId]) extends HasTxNodes with CidContainer[Transaction] with Product with Serializable

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.

Linear Supertypes
Serializable, Product, Equals, CidContainer[Transaction], HasTxNodes, AnyRef, Any
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. Transaction
  2. Serializable
  3. Product
  4. Equals
  5. CidContainer
  6. HasTxNodes
  7. AnyRef
  8. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. Protected

Instance Constructors

  1. new Transaction(nodes: Map[NodeId, Node], roots: ImmArray[NodeId])

    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.

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. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def cids: Set[ContractId]
    Definition Classes
    CidContainer
  6. def clone(): AnyRef
    Attributes
    protected[lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native() @IntrinsicCandidate()
  7. def collectCids(acc: Set[ContractId]): Set[ContractId]
    Definition Classes
    CidContainer
  8. def compareForest(other: Transaction)(compare: (Node, Node) => Boolean): Boolean

    Compares two Transactions up to renaming of Nids.

    Compares two Transactions up to renaming of Nids. with the specified comparision of nodes Nid is irrelevant to the content of the transaction.

  9. final def consumedBy: Map[ContractId, NodeId]

    Keys are contracts (that have been consumed) and values are the nodes where the contract was consumed.

    Keys are contracts (that have been consumed) and values are the nodes where the contract was consumed. Nodes under rollbacks (both exercises and creates) are ignored (as they have been rolled back). The result includes both local contracts created in the transaction (if they’ve been consumed) as well as global contracts created in previous transactions. It does not include local contracts created under a rollback.

    Definition Classes
    HasTxNodes
  10. final def consumedContracts[Cid2 >: ContractId]: Set[Cid2]

    Returns the IDs of all the consumed contracts.

    Returns the IDs of all the consumed contracts. This includes transient contracts but it does not include contracts consumed in rollback nodes.

    Definition Classes
    HasTxNodes
  11. def contractKeyInputs: Either[KeyInputError, Map[GlobalKey, KeyInput]]

    Return the expected contract key inputs (i.e.

    Return the expected contract key inputs (i.e. the state before the transaction) for this transaction or an error if the transaction contains a duplicate key error or has an inconsistent mapping for a key. For KeyCreate and NegativeKeyLookup (both corresponding to the key not being active) the first required input in execution order wins. So if a create comes first the input will be set to KeyCreate, if a negative lookup by key comes first the input will be set to NegativeKeyLookup.

    Because we do not preserve byKey flags across transaction serialization this method will consider all operations with keys for conflicts rather than just by-key operations.

    Definition Classes
    HasTxNodes
    Annotations
    @throws("If a contract key contains a contract id")
  12. final def contractKeys: Set[GlobalKey]

    Return all the contract keys referenced by this transaction.

    Return all the contract keys referenced by this transaction. This includes the keys created, exercised, fetched, or looked up, even those that refer transient contracts or that appear under a rollback node.

    Definition Classes
    HasTxNodes
  13. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  14. def equalForest(other: Transaction): Boolean

    Compares two Transactions up to renaming of Nids.

    Compares two Transactions up to renaming of Nids. You most likely want to use this rather than ==, since the Nid is irrelevant to the content of the transaction.

  15. final def fold[A](z: A)(f: (A, (NodeId, Node)) => A): A

    Traverses the transaction tree in pre-order traversal (i.e.

    Traverses the transaction tree in pre-order traversal (i.e. exercise nodes are traversed before their children)

    Takes constant stack space. Crashes if the transaction is not well formed (see isWellFormed)

    Definition Classes
    HasTxNodes
  16. final def foldInExecutionOrder[A](z: A)(exerciseBegin: (A, NodeId, Exercise) => (A, ChildrenRecursion), rollbackBegin: (A, NodeId, Rollback) => (A, ChildrenRecursion), leaf: (A, NodeId, LeafOnlyAction) => A, exerciseEnd: (A, NodeId, Exercise) => A, rollbackEnd: (A, NodeId, Rollback) => A): A
    Definition Classes
    HasTxNodes
  17. def foldValues[Z](z: Z)(f: (Z, Value) => Z): Z

    Visit every Val.

  18. final def foldWithPathState[A, B](globalState0: A, pathState0: B)(op: (A, B, NodeId, Node) => (A, B)): A

    A fold over the transaction that maintains global and path-specific state.

    A fold over the transaction that maintains global and path-specific state. Takes constant stack space. Returns the global state.

    Used to for example compute the roots of per-party projections from the transaction.

    Definition Classes
    HasTxNodes
  19. final def foreach(f: (NodeId, Node) => Unit): Unit

    This function traverses the transaction tree in pre-order traversal (i.e.

    This function traverses the transaction tree in pre-order traversal (i.e. exercise node are traversed before their children).

    Takes constant stack space. Crashes if the transaction is not well formed (see isWellFormed)

    Definition Classes
    HasTxNodes
  20. def foreachCid(f: (ContractId) => Unit): Unit
    Definition Classes
    CidContainer
  21. final def foreachInExecutionOrder(exerciseBegin: (NodeId, Exercise) => ChildrenRecursion, rollbackBegin: (NodeId, Rollback) => ChildrenRecursion, leaf: (NodeId, LeafOnlyAction) => Unit, exerciseEnd: (NodeId, Exercise) => Unit, rollbackEnd: (NodeId, Rollback) => Unit): Unit
    Definition Classes
    HasTxNodes
  22. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native() @IntrinsicCandidate()
  23. final def guessSubmitter: Either[String, Party]
    Definition Classes
    HasTxNodes
  24. final def inactiveContracts[Cid2 >: ContractId]: Set[Cid2]

    Local and global contracts that are inactive at the end of the transaction.

    Local and global contracts that are inactive at the end of the transaction. This includes both contracts that have been arachived and local contracts whose create has been rolled back.

    Definition Classes
    HasTxNodes
  25. lazy val informees: Set[Party]

    The union of the informees of all the action nodes.

    The union of the informees of all the action nodes.

    Definition Classes
    HasTxNodes
  26. final def inputContracts[Cid2 >: ContractId]: Set[Cid2]

    Returns the IDs of all input contracts that are used by this transaction.

    Returns the IDs of all input contracts that are used by this transaction.

    Definition Classes
    HasTxNodes
  27. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  28. def isWellFormed: Set[NotWellFormedError]

    This function checks the following properties:

    This function checks the following properties:

    * No dangling references -- all node ids mentioned in the forest are in the nodes map; * No orphaned references -- all keys of the node map are mentioned in the forest; * No aliasing -- every node id in the node map is mentioned exactly once, in the roots list or as a child of another node.

  29. final def localContracts[Cid2 >: ContractId]: Map[Cid2, (NodeId, Create)]
    Definition Classes
    HasTxNodes
  30. def mapCid(f: (ContractId) => ContractId): Transaction
    Definition Classes
    Transaction → CidContainer
  31. def mapNodeId(f: (NodeId) => NodeId): Transaction
  32. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  33. val nodes: Map[NodeId, Node]
    Definition Classes
    Transaction → HasTxNodes
  34. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  35. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native() @IntrinsicCandidate()
  36. def productElementNames: Iterator[String]
    Definition Classes
    Product
  37. final def reachableNodeIds: Set[NodeId]
    Definition Classes
    HasTxNodes
  38. def rootNodes: ImmArray[Action]
    Definition Classes
    HasTxNodes
    Annotations
    @throws(scala.this.throws.<init>$default$1[IllegalArgumentException])
  39. val roots: ImmArray[NodeId]
    Definition Classes
    Transaction → HasTxNodes
  40. def self: Transaction.this.type
    Attributes
    protected
    Definition Classes
    Transaction → CidContainer
  41. def serializable(f: (Value) => ImmArray[String]): ImmArray[String]

    checks that all the values contained are serializable

  42. final def suffixCid(f: (Hash) => Bytes): Either[String, Transaction]
    Definition Classes
    CidContainer
  43. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  44. def traverseCid[L](f: (ContractId) => Either[L, ContractId]): Either[L, Transaction]
    Definition Classes
    CidContainer
  45. final def updatedContractKeys: Map[GlobalKey, Option[ContractId]]

    The contract keys created or updated as part of the transaction.

    The contract keys created or updated as part of the transaction. This includes updates to transient contracts (by mapping them to None) but it does not include any updates under rollback nodes.

    Definition Classes
    HasTxNodes
  46. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  47. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  48. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])

Deprecated Value Members

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

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from CidContainer[Transaction]

Inherited from HasTxNodes

Inherited from AnyRef

Inherited from Any

Ungrouped