WireTransaction - corda

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(componentGroups: List<ComponentGroup>)` `WireTransaction(inputs: List<StateRef>, attachments: List<SecureHash>, outputs: List<TransactionState<ContractState>>, commands: List<Command<*>>, notary: Party?, timeWindow: TimeWindow?, privacySalt: PrivacySalt = PrivacySalt())` Old version of WireTransaction constructor for ABI compatibility. `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). `WireTransaction(componentGroups: List<ComponentGroup>, privacySalt: PrivacySalt, digestService: DigestService)`

### Properties

#### id | The transaction id is represented by the root hash of Merkle tree over the transaction components. `val id: SecureHash`
#### 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 merkleTree: MerkleTree`
#### privacySalt | `val privacySalt: PrivacySalt`
#### requiredSigningKeys | Public keys that need to be fulfilled by signatures in order for the transaction to be valid. `val requiredSigningKeys: Set<PublicKey>`

### Functions

#### buildFilteredTransaction | Build filtered transaction using provided filtering functions. `fun buildFilteredTransaction(filtering: Predicate<Any>): FilteredTransaction`
#### checkSignature | Checks that the given signature matches one of the commands and that it is a correct signature over the tx. `fun checkSignature(sig: TransactionSignature): Unit`
#### equals | `fun equals(other: Any?): Boolean`
#### hashCode | `fun hashCode(): Int`
#### toLedgerTransaction | 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(services: ServicesForResolution): 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 toLedgerTransaction(resolveIdentity: (PublicKey) -> Party?, resolveAttachment: (SecureHash) -> Attachment?, resolveStateRef: (StateRef) -> TransactionState<*>?, resolveContractAttachment: (TransactionState<ContractState>) -> AttachmentId?): LedgerTransaction`
#### 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>`
#### resolveStateRefBinaryComponent | This is the main logic that knows how to retrieve the binary representation of StateRefs. `fun resolveStateRefBinaryComponent(stateRef: StateRef, services: ServicesForResolution): SerializedBytes<TransactionState<ContractState>>?`