SignedTransaction

net.corda.core.transactions.SignedTransaction

All Implemented Interfaces:

NamedByHash
```
public class SignedTransaction
implements NamedByHash
```
SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the class WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.

See Also:

class WireTransaction

Constructor Summary

Constructors
Constructor and Description
`SignedTransaction(SerializedBytes<net.corda.core.transactions.WireTransaction> txBits, java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)` SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the `class WireTransaction` Merkle tree root. Thus adding or removing a signature does not change it.
`SignedTransaction(WireTransaction wtx, java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`checkSignaturesAreValid()` Mathematically validates the signatures that are present on this transaction. This does not imply that the signatures are by the right keys, or that there are sufficient signatures, just that they aren't corrupt. If you use this function directly you'll need to do the other checks yourself. Probably you want verifySignaturesExcept instead.
`SerializedBytes<net.corda.core.transactions.WireTransaction>`	`component1()`
`java.util.List<net.corda.core.crypto.DigitalSignature.WithKey>`	`component2()`
`SignedTransaction`	`copy(SerializedBytes<net.corda.core.transactions.WireTransaction> txBits, java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)` SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the `class WireTransaction` Merkle tree root. Thus adding or removing a signature does not change it.
`boolean`	`equals(java.lang.Object p)`
`SecureHash`	`getId()` The id of the contained `class WireTransaction`.
`java.util.List<net.corda.core.crypto.DigitalSignature.WithKey>`	`getSigs()`
`WireTransaction`	`getTx()` Lazily calculated access to the deserialised/hashed transaction data.
`SerializedBytes<net.corda.core.transactions.WireTransaction>`	`getTxBits()`
`int`	`hashCode()`
`SignedTransaction`	`plus(DigitalSignature.WithKey sig)` Alias for `SignedTransaction.withAdditionalSignature` to let you use Kotlin operator overloading.
`SignedTransaction`	`plus(java.util.Collection<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigList)` Alias for withAdditionalSignatures to let you use Kotlin operator overloading.
`LedgerTransaction`	`toLedgerTransaction(ServiceHub services, boolean checkSufficientSignatures)` Checks the transaction's signatures are valid, optionally calls `SignedTransaction.verifyRequiredSignatures` to check all required signatures are present, and then calls `WireTransaction.toLedgerTransaction` with the passed in `interface ServiceHub` to resolve the dependencies, returning an unverified LedgerTransaction.
`LedgerTransaction`	`toLedgerTransaction(ServiceHub services)` Checks the transaction's signatures are valid, optionally calls `SignedTransaction.verifyRequiredSignatures` to check all required signatures are present, and then calls `WireTransaction.toLedgerTransaction` with the passed in `interface ServiceHub` to resolve the dependencies, returning an unverified LedgerTransaction.
`java.lang.String`	`toString()`
`void`	`verify(ServiceHub services, boolean checkSufficientSignatures)` Checks the transaction's signatures are valid, optionally calls `SignedTransaction.verifyRequiredSignatures` to check all required signatures are present, calls `WireTransaction.toLedgerTransaction` with the passed in `interface ServiceHub` to resolve the dependencies and return an unverified LedgerTransaction, then verifies the LedgerTransaction.
`void`	`verify(ServiceHub services)` Checks the transaction's signatures are valid, optionally calls `SignedTransaction.verifyRequiredSignatures` to check all required signatures are present, calls `WireTransaction.toLedgerTransaction` with the passed in `interface ServiceHub` to resolve the dependencies and return an unverified LedgerTransaction, then verifies the LedgerTransaction.
`WireTransaction`	`verifyRequiredSignatures()` Verifies the signatures on this transaction and throws if any are missing. In this context, "verifying" means checking they are valid signatures and that their public keys are in the contained transactions BaseTransaction.mustSign property.
`WireTransaction`	`verifySignaturesExcept(java.security.PublicKey allowedToBeMissing)` Verifies the signatures on this transaction and throws if any are missing which aren't passed as parameters. In this context, "verifying" means checking they are valid signatures and that their public keys are in the contained transactions BaseTransaction.mustSign property.
`SignedTransaction`	`withAdditionalSignature(DigitalSignature.WithKey sig)` Returns the same transaction but with an additional (unchecked) signature.
`SignedTransaction`	`withAdditionalSignatures(java.lang.Iterable<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigList)` Returns the same transaction but with an additional (unchecked) signatures.

Methods inherited from interface net.corda.core.contracts.NamedByHash
getId

- Constructor Detail
  - SignedTransaction
```
public SignedTransaction(SerializedBytes<net.corda.core.transactions.WireTransaction> txBits,
                         java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)
```
    SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the class WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.
    
    Parameters:
    
    sigs - a list of signatures from individual (non-composite) public keys. This is passed as a list of signatures when verifying composite key signatures, but may be used as individual signatures where a single key is expected to sign.
    
    See Also:
    
    class WireTransaction
  - SignedTransaction
```
public SignedTransaction(WireTransaction wtx,
                         java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)
```
- Method Detail
  - getTx
```
public WireTransaction getTx()
```
    Lazily calculated access to the deserialised/hashed transaction data.
  - getId
```
public SecureHash getId()
```
    The id of the contained class WireTransaction.
    
    See Also:
    
    class WireTransaction
  - verifyRequiredSignatures
```
public WireTransaction verifyRequiredSignatures()
```
    Verifies the signatures on this transaction and throws if any are missing. In this context, "verifying" means checking they are valid signatures and that their public keys are in the contained transactions BaseTransaction.mustSign property.
    
    Throws:
    
    - if any signatures are invalid or unrecognised.
    
    - if any signatures should have been present but were not.
  - verifySignaturesExcept
```
public WireTransaction verifySignaturesExcept(java.security.PublicKey allowedToBeMissing)
```
    Verifies the signatures on this transaction and throws if any are missing which aren't passed as parameters. In this context, "verifying" means checking they are valid signatures and that their public keys are in the contained transactions BaseTransaction.mustSign property.
    Normally you would not provide any keys to this function, but if you're in the process of building a partial transaction and you want to access the contents before you've signed it, you can specify your own keys here to bypass that check.
    
    Throws:
    
    - if any signatures are invalid or unrecognised.
    
    - if any signatures should have been present but were not.
  - checkSignaturesAreValid
```
public void checkSignaturesAreValid()
```
    Mathematically validates the signatures that are present on this transaction. This does not imply that the signatures are by the right keys, or that there are sufficient signatures, just that they aren't corrupt. If you use this function directly you'll need to do the other checks yourself. Probably you want verifySignaturesExcept instead.
    
    Throws:
    
    - if a signature fails to verify.
  - withAdditionalSignature
```
public SignedTransaction withAdditionalSignature(DigitalSignature.WithKey sig)
```
    Returns the same transaction but with an additional (unchecked) signature.
  - withAdditionalSignatures
```
public SignedTransaction withAdditionalSignatures(java.lang.Iterable<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigList)
```
    Returns the same transaction but with an additional (unchecked) signatures.
  - plus
```
public SignedTransaction plus(DigitalSignature.WithKey sig)
```
    Alias for SignedTransaction.withAdditionalSignature to let you use Kotlin operator overloading.
    
    See Also:
    
    SignedTransaction.withAdditionalSignature
  - plus
```
public SignedTransaction plus(java.util.Collection<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigList)
```
    Alias for withAdditionalSignatures to let you use Kotlin operator overloading.
  - toLedgerTransaction
```
public LedgerTransaction toLedgerTransaction(ServiceHub services,
                                             boolean checkSufficientSignatures)
```
    Checks the transaction's signatures are valid, optionally calls SignedTransaction.verifyRequiredSignatures to check all required signatures are present, and then calls WireTransaction.toLedgerTransaction with the passed in interface ServiceHub to resolve the dependencies, returning an unverified LedgerTransaction.
    This allows us to perform validation over the entirety of the transaction's contents. WireTransaction only contains StateRef for the inputs and hashes for the attachments, rather than ContractState instances for the inputs and Attachment instances for the attachments.
    
    Throws:
    
    - if a required attachment was not found in storage.
    
    - if an input points to a transaction not found in storage.
    
    - if any signatures were invalid or unrecognised
    
    - if any signatures that should have been present are missing.
    
    See Also:
    
    SignedTransaction.verifyRequiredSignatures, WireTransaction.toLedgerTransaction, interface ServiceHub
  - toLedgerTransaction
```
public LedgerTransaction toLedgerTransaction(ServiceHub services)
```
    Checks the transaction's signatures are valid, optionally calls SignedTransaction.verifyRequiredSignatures to check all required signatures are present, and then calls WireTransaction.toLedgerTransaction with the passed in interface ServiceHub to resolve the dependencies, returning an unverified LedgerTransaction.
    This allows us to perform validation over the entirety of the transaction's contents. WireTransaction only contains StateRef for the inputs and hashes for the attachments, rather than ContractState instances for the inputs and Attachment instances for the attachments.
    
    Throws:
    
    - if a required attachment was not found in storage.
    
    - if an input points to a transaction not found in storage.
    
    - if any signatures were invalid or unrecognised
    
    - if any signatures that should have been present are missing.
    
    See Also:
    
    SignedTransaction.verifyRequiredSignatures, WireTransaction.toLedgerTransaction, interface ServiceHub
  - verify
```
public void verify(ServiceHub services,
                   boolean checkSufficientSignatures)
```
    Checks the transaction's signatures are valid, optionally calls SignedTransaction.verifyRequiredSignatures to check all required signatures are present, calls WireTransaction.toLedgerTransaction with the passed in interface ServiceHub to resolve the dependencies and return an unverified LedgerTransaction, then verifies the LedgerTransaction.
    
    Throws:
    
    - if a required attachment was not found in storage.
    
    - if an input points to a transaction not found in storage.
    
    - if any signatures were invalid or unrecognised
    
    - if any signatures that should have been present are missing.
    
    See Also:
    
    SignedTransaction.verifyRequiredSignatures, WireTransaction.toLedgerTransaction, interface ServiceHub
  - verify
```
public void verify(ServiceHub services)
```
    Checks the transaction's signatures are valid, optionally calls SignedTransaction.verifyRequiredSignatures to check all required signatures are present, calls WireTransaction.toLedgerTransaction with the passed in interface ServiceHub to resolve the dependencies and return an unverified LedgerTransaction, then verifies the LedgerTransaction.
    
    Throws:
    
    - if a required attachment was not found in storage.
    
    - if an input points to a transaction not found in storage.
    
    - if any signatures were invalid or unrecognised
    
    - if any signatures that should have been present are missing.
    
    See Also:
    
    SignedTransaction.verifyRequiredSignatures, WireTransaction.toLedgerTransaction, interface ServiceHub
  - toString
```
public java.lang.String toString()
```
  - getTxBits
```
public SerializedBytes<net.corda.core.transactions.WireTransaction> getTxBits()
```
  - getSigs
```
public java.util.List<net.corda.core.crypto.DigitalSignature.WithKey> getSigs()
```
  - component1
```
public SerializedBytes<net.corda.core.transactions.WireTransaction> component1()
```
  - component2
```
public java.util.List<net.corda.core.crypto.DigitalSignature.WithKey> component2()
```
  - copy
```
public SignedTransaction copy(SerializedBytes<net.corda.core.transactions.WireTransaction> txBits,
                              java.util.List<? extends net.corda.core.crypto.DigitalSignature.WithKey> sigs)
```
    SignedTransaction wraps a serialized WireTransaction. It contains one or more signatures, each one for a public key (including composite keys) that is mentioned inside a transaction command. SignedTransaction is the top level transaction type and the type most frequently passed around the network and stored. The identity of a transaction is the hash of Merkle root of a WireTransaction, therefore if you are storing data keyed by WT hash be aware that multiple different STs may map to the same key (and they could be different in important ways, like validity!). The signatures on a SignedTransaction might be invalid or missing: the type does not imply validity. A transaction ID should be the hash of the class WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.
    
    Parameters:
    
    sigs - a list of signatures from individual (non-composite) public keys. This is passed as a list of signatures when verifying composite key signatures, but may be used as individual signatures where a single key is expected to sign.
    
    See Also:
    
    class WireTransaction
  - hashCode
```
public int hashCode()
```
  - equals
```
public boolean equals(java.lang.Object p)
```

Class SignedTransaction

Constructor Summary

Method Summary

Methods inherited from interface net.corda.core.contracts.NamedByHash

Constructor Detail

SignedTransaction

SignedTransaction

Method Detail

getTx

getId

verifyRequiredSignatures

verifySignaturesExcept

checkSignaturesAreValid

withAdditionalSignature

withAdditionalSignatures

plus

plus

toLedgerTransaction

toLedgerTransaction

verify

verify

toString

getTxBits

getSigs

component1

component2

copy

hashCode

equals