corda / net.corda.core.transactions / WireTransaction


class WireTransaction : TraversableTransaction

A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped by a SignedTransaction that carries the signatures over this payload. The identity of the transaction is the Merkle tree root of its components (see MerkleTree).

For privacy purposes, each part of a transaction should be accompanied by a nonce. To avoid storing a random number (nonce) per component, an initial privacySalt is the sole value utilised, so that all component nonces are deterministically computed.

A few notes about backwards compatibility: A wire transaction can be backwards compatible, in the sense that if an old client receives a componentGroups with more elements than expected, it will normally deserialise the required objects and omit any checks in the optional new fields. Moreover, because the Merkle tree is constructed from the received list of ComponentGroup, which internally deals with bytes, any client can compute the Merkle tree and on the same time relay a WireTransaction object even if she is unable to read some of the "optional" component types. We stress that practically, a new type of WireTransaction should only be considered compatible if and only if the following rules apply:



WireTransaction(componentGroups: List<ComponentGroup>)
WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt = PrivacySalt())WireTransaction(componentGroups: List<ComponentGroup>, privacySalt: PrivacySalt = PrivacySalt())

Old version of WireTransaction constructor for ABI compatibility.

WireTransaction(componentGroups: List<ComponentGroup>, privacySalt: PrivacySalt, digestService: DigestService)

A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped by a SignedTransaction that carries the signatures over this payload. The identity of the transaction is the Merkle tree root of its components (see MerkleTree).



val id: SecureHash

The transaction id is represented by the root hash of Merkle tree over the transaction components.


val merkleTree: MerkleTree

Builds whole Merkle tree for a transaction. Briefly, each component group has its own sub Merkle tree and all of the roots of these trees are used as leaves in a top level Merkle tree. Note that ordering of elements inside a ComponentGroup matters when computing the Merkle root. On the other hand, insertion group ordering does not affect the top level Merkle tree construction, as it is actually an ordered Merkle tree, where its leaves are ordered based on the group ordinal in ComponentGroupEnum. If any of the groups is an empty list or a null object, then SecureHash.allOnesHash is used as its hash. Also, privacySalt is not a Merkle tree leaf, because it is already "inherently" included via the component nonces.


val privacySalt: PrivacySalt


val requiredSigningKeys: Set<PublicKey>

Public keys that need to be fulfilled by signatures in order for the transaction to be valid.

Inherited Properties


val attachments: List<SecureHash>

Hashes of the ZIP/JAR files that are needed to interpret the contents of this wire transaction.


val availableComponentGroups: List<List<Any>>

Returns a list of all the component groups that are present in the transaction, excluding the privacySalt, in the following order (which is the same with the order in ComponentGroupEnum:


val commands: List<Command<*>>

Ordered list of (CommandData, PublicKey) pairs that instruct the contracts what to do.


open val componentGroups: List<ComponentGroup>


val digestService: DigestService


open val inputs: List<StateRef>

Pointers to the input states on the ledger, identified by (tx identity hash, output index).


open val networkParametersHash: SecureHash?

Hash of the network parameters that were in force when the transaction was notarised. Null means, that the transaction was created on older version of Corda (before 4), resolution will default to initial parameters.


open val notary: Party?

If present, the notary for this transaction. If absent then the transaction is not notarised at all. This is intended for issuance/genesis transactions that don't consume any other states and thus can't double spend anything.


open val outputs: List<TransactionState<ContractState>>

Ordered list of states defined by this transaction, along with the associated notaries.


open val references: List<StateRef>

Pointers to reference states, identified by (tx identity hash, output index).


val timeWindow: TimeWindow?



fun buildFilteredTransaction(filtering: Predicate<Any>): FilteredTransaction

Build filtered transaction using provided filtering functions.


fun checkSignature(sig: TransactionSignature): Unit

Checks that the given signature matches one of the commands and that it is a correct signature over the tx.


fun equals(other: Any?): Boolean


fun hashCode(): Int


fun toLedgerTransaction(services: ServicesForResolution): LedgerTransaction

Looks up identities and attachments from storage to generate a LedgerTransaction. A transaction is expected to have been fully resolved using the resolution flow by this point.

fun toLedgerTransaction(resolveIdentity: (PublicKey) -> Party?, resolveAttachment: (SecureHash) -> Attachment?, resolveStateRef: (StateRef) -> TransactionState<*>?, resolveContractAttachment: (TransactionState<ContractState>) -> AttachmentId?): LedgerTransaction

Looks up identities, attachments and dependent input states using the provided lookup functions in order to construct a LedgerTransaction. Note that identity lookup failure does not cause an exception to be thrown. This invocation doesn't check various rules like no-downgrade or package namespace ownership.


fun toString(): String

Companion Object Functions


fun createComponentGroups(inputs: List<StateRef>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, attachments: List<SecureHash>, notary: Party?, timeWindow: TimeWindow?): List<ComponentGroup>


fun resolveStateRefBinaryComponent(stateRef: StateRef, services: ServicesForResolution): SerializedBytes<TransactionState<ContractState>>?

This is the main logic that knows how to retrieve the binary representation of StateRefs.

Extension Functions


fun Any.contextLogger(): <ERROR CLASS>

When called from a companion object, returns the logger for the enclosing class.