WireTransaction
Keywords: net.corda.core.transactions.WireTransaction class
Date: 2023-09-18

net.corda.core.transactions

## Class WireTransaction

- net.corda.core.transactions.BaseTransaction
- - net.corda.core.transactions.CoreTransaction
  - - TraversableTransaction
    - - net.corda.core.transactions.WireTransaction

- All Implemented Interfaces:
    NamedByHash

      public class WireTransaction
      extends TraversableTransaction

  A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped by a `class SignedTransaction` that carries the signatures over this payload. The identity of the transaction is the Merkle tree root of its components (see `class 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 `class ComponentGroup`, which internally deals with bytes, any client can compute the Merkle tree and on the same time relay a `class WireTransaction` object even if she is unable to read some of the "optional" component types. We stress that practically, a new type of `class WireTransaction` should only be considered compatible if and only if the following rules apply:

  See Also:
    `class SignedTransaction`, `class MerkleTree`, `class ComponentGroup`, `class WireTransaction`, `class WireTransaction`

- - ### Field Detail

    - #### Companion

          public static net.corda.core.transactions.WireTransaction.Companion Companion

  - ### Constructor Detail

    - #### WireTransaction

          public WireTransaction(@NotNull
                                 java.util.List<? extends net.corda.core.transactions.ComponentGroup> componentGroups,
                                 @NotNull
                                 PrivacySalt privacySalt,
                                 @NotNull
                                 DigestService digestService)

      A transaction ready for serialisation, without any signatures attached. A WireTransaction is usually wrapped by a `class SignedTransaction` that carries the signatures over this payload. The identity of the transaction is the Merkle tree root of its components (see `class 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 `class ComponentGroup`, which internally deals with bytes, any client can compute the Merkle tree and on the same time relay a `class WireTransaction` object even if she is unable to read some of the "optional" component types. We stress that practically, a new type of `class WireTransaction` should only be considered compatible if and only if the following rules apply:

      See Also:
        `class SignedTransaction`, `class MerkleTree`, `class ComponentGroup`, `class WireTransaction`, `class WireTransaction`

    - #### WireTransaction

          public WireTransaction(@NotNull
                                 java.util.List<? extends net.corda.core.transactions.ComponentGroup> componentGroups)

    - #### WireTransaction

          public WireTransaction(@NotNull
                                 java.util.List<? extends net.corda.core.transactions.ComponentGroup> componentGroups,
                                 @NotNull
                                 PrivacySalt privacySalt)

      Old version of `class WireTransaction` constructor for ABI compatibility.

      See Also:
        `class WireTransaction`

    - #### WireTransaction

          @Deprecated
           @JvmOverloads
          public WireTransaction(@NotNull
                                                            java.util.List<net.corda.core.contracts.StateRef> inputs,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.crypto.SecureHash> attachments,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.contracts.TransactionState<? extends net.corda.core.contracts.ContractState>> outputs,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.contracts.Command<?>> commands,
                                                            @Nullable
                                                            Party notary,
                                                            @Nullable
                                                            TimeWindow timeWindow,
                                                            @NotNull
                                                            PrivacySalt privacySalt)

      Deprecated.

    - #### WireTransaction

          @Deprecated
           @JvmOverloads
          public WireTransaction(@NotNull
                                                            java.util.List<net.corda.core.contracts.StateRef> inputs,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.crypto.SecureHash> attachments,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.contracts.TransactionState<? extends net.corda.core.contracts.ContractState>> outputs,
                                                            @NotNull
                                                            java.util.List<? extends net.corda.core.contracts.Command<?>> commands,
                                                            @Nullable
                                                            Party notary,
                                                            @Nullable
                                                            TimeWindow timeWindow)

      Deprecated.

  - ### Method Detail

    - #### getId

          @NotNull
          public SecureHash getId()

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

    - #### getRequiredSigningKeys

          @NotNull
          public java.util.Set<java.security.PublicKey> getRequiredSigningKeys()

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

    - #### toLedgerTransaction

          @NotNull
          public LedgerTransaction toLedgerTransaction(@NotNull
                                                                ServicesForResolution services)

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

      Throws:
        `AttachmentResolutionException` - if a required attachment was not found in storage.
        `TransactionResolutionException` - if an input points to a transaction not found in storage.
      See Also:
        `class LedgerTransaction`

    - #### toLedgerTransaction

          @Deprecated
           @NotNull
          public LedgerTransaction toLedgerTransaction(@NotNull
                                                                             kotlin.jvm.functions.Function1<? super java.security.PublicKey,net.corda.core.identity.Party> resolveIdentity,
                                                                             @NotNull
                                                                             kotlin.jvm.functions.Function1<? super net.corda.core.crypto.SecureHash,? extends net.corda.core.contracts.Attachment> resolveAttachment,
                                                                             @NotNull
                                                                             kotlin.jvm.functions.Function1<? super net.corda.core.contracts.StateRef,? extends net.corda.core.contracts.TransactionState<?>> resolveStateRef,
                                                                             @NotNull
                                                                             kotlin.jvm.functions.Function1<? super net.corda.core.contracts.TransactionState<? extends net.corda.core.contracts.ContractState>,? extends net.corda.core.crypto.SecureHash> resolveContractAttachment)

      Deprecated.

      Looks up identities, attachments and dependent input states using the provided lookup functions in order to construct a `class 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.

      Throws:
        `AttachmentResolutionException` - if a required attachment was not found using `resolveAttachment`.
        `TransactionResolutionException` - if an input was not found not using `resolveStateRef`.
      See Also:
        `class LedgerTransaction`

    - #### buildFilteredTransaction

          @NotNull
          public FilteredTransaction buildFilteredTransaction(@NotNull
                                                                       java.util.function.Predicate<java.lang.Object> filtering)

      Build filtered transaction using provided filtering functions.

    - #### getMerkleTree

          @NotNull
          public MerkleTree getMerkleTree()

      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 `class 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 `enum 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.

      See Also:
        `class ComponentGroup`, `enum ComponentGroupEnum`

    - #### checkSignature

          public void checkSignature(@NotNull
                                     TransactionSignature sig)

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

      Throws:
        `SignatureException` - if the signature didn't match the transaction contents.
        `IllegalArgumentException` - if the signature key doesn't appear in any command.

    - #### toString

          @NotNull
          public java.lang.String toString()

    - #### equals

          public boolean equals(@Nullable
                                java.lang.Object other)

    - #### hashCode

          public int hashCode()

    - #### getPrivacySalt

          @NotNull
          public PrivacySalt getPrivacySalt()