corda / net.corda.core.transactions / WireTransaction

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:

Constructors

<init>

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())

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).

Properties

id

val id: SecureHash

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

merkleTree

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.

privacySalt

val privacySalt: PrivacySalt

requiredSigningKeys

val requiredSigningKeys: Set<PublicKey>

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

Inherited Properties

attachments

val attachments: List<SecureHash>

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

availableComponentGroups

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:

commands

val commands: List<Command<*>>

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

componentGroups

open val componentGroups: List<ComponentGroup>

inputs

open val inputs: List<StateRef>

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

notary

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.

outputs

open val outputs: List<TransactionState<ContractState>>

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

timeWindow

val timeWindow: TimeWindow?

Functions

buildFilteredTransaction

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

Build filtered transaction using provided filtering functions.

checkSignature

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.

equals

fun equals(other: Any?): Boolean

hashCode

fun hashCode(): Int

toLedgerTransaction

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.

toString

fun toString(): String

Companion Object Functions

createComponentGroups

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

Creating list of ComponentGroup used in one of the constructors of WireTransaction required for backwards compatibility purposes.

Extension Functions

contextLogger

fun Any.contextLogger(): Logger

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