corda / net.corda.core.transactions / SignedTransaction

SignedTransaction

data class SignedTransaction : TransactionWithSignatures

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

Exceptions

SignaturesMissingException

class SignaturesMissingException : NamedByHash, SignatureException, CordaThrowable

Constructors

<init>

SignedTransaction(ctx: CoreTransaction, sigs: List<TransactionSignature>)SignedTransaction(txBits: SerializedBytes<CoreTransaction>, sigs: List<TransactionSignature>)

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 WireTransaction Merkle tree root. Thus adding or removing a signature does not change it.

Properties

coreTransaction

val coreTransaction: CoreTransaction

Lazily calculated access to the deserialised/hashed transaction data.

id

val id: SecureHash

The id of the contained WireTransaction.

inputs

val inputs: List<StateRef>

Helper to access the inputs of the contained transaction.

notary

val notary: Party?

Helper to access the notary of the contained transaction.

notaryChangeTx

val notaryChangeTx: NotaryChangeWireTransaction

Returns the contained NotaryChangeWireTransaction, or throws if this is a normal transaction.

requiredSigningKeys

val requiredSigningKeys: Set<PublicKey>

Specifies all the public keys that require signatures for the transaction to be valid.

sigs

val sigs: List<TransactionSignature>

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.

tx

val tx: WireTransaction

Returns the contained WireTransaction, or throws if this is a notary change or contract upgrade transaction.

txBits

val txBits: SerializedBytes<CoreTransaction>

Functions

buildFilteredTransaction

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

Helper function to directly build a FilteredTransaction using provided filtering functions, without first accessing the WireTransaction.

getKeyDescriptions

fun getKeyDescriptions(keys: Set<PublicKey>): ArrayList<String>

Get a human readable description of where signatures are required from, and are missing, to assist in debugging the underlying cause.

isNotaryChangeTransaction

fun isNotaryChangeTransaction(): Boolean

plus

operator fun plus(sig: TransactionSignature): SignedTransaction

Alias for withAdditionalSignature to let you use Kotlin operator overloading.

operator fun plus(sigList: Collection<TransactionSignature>): SignedTransaction

Alias for withAdditionalSignatures to let you use Kotlin operator overloading.

resolveBaseTransaction

fun resolveBaseTransaction(servicesForResolution: ServicesForResolution): BaseTransaction

Resolves the underlying base transaction and then returns it, handling any special case transactions such as NotaryChangeWireTransaction.

resolveContractUpgradeTransaction

fun resolveContractUpgradeTransaction(services: ServicesForResolution): ContractUpgradeLedgerTransaction

If coreTransaction is a ContractUpgradeWireTransaction, loads the input states and resolves it to a ContractUpgradeLedgerTransaction so the signatures can be verified.

resolveNotaryChangeTransaction

fun resolveNotaryChangeTransaction(services: ServicesForResolution): NotaryChangeLedgerTransaction
fun resolveNotaryChangeTransaction(services: ServiceHub): NotaryChangeLedgerTransaction

If transaction is a NotaryChangeWireTransaction, loads the input states and resolves it to a NotaryChangeLedgerTransaction so the signatures can be verified.

resolveTransactionWithSignatures

fun resolveTransactionWithSignatures(services: ServicesForResolution): TransactionWithSignatures

Resolves the underlying transaction with signatures and then returns it, handling any special case transactions such as NotaryChangeWireTransaction.

toLedgerTransaction

fun toLedgerTransaction(services: ServiceHub, checkSufficientSignatures: Boolean = true): LedgerTransaction

Checks the transaction's signatures are valid, optionally calls verifyRequiredSignatures to check all required signatures are present, and then calls WireTransaction.toLedgerTransaction with the passed in ServiceHub to resolve the dependencies, returning an unverified LedgerTransaction.

toString

fun toString(): String

verify

fun verify(services: ServiceHub, checkSufficientSignatures: Boolean = true): Unit

Checks the transaction's signatures are valid, optionally calls verifyRequiredSignatures to check all required signatures are present. Resolves inputs and attachments from the local storage and performs full transaction verification, including running the contracts.

withAdditionalSignature

fun withAdditionalSignature(keyPair: KeyPair, signatureMetadata: SignatureMetadata): SignedTransactionfun withAdditionalSignature(sig: TransactionSignature): SignedTransaction

Returns the same transaction but with an additional (unchecked) signature.

withAdditionalSignatures

fun withAdditionalSignatures(sigList: Iterable<TransactionSignature>): SignedTransaction

Returns the same transaction but with an additional (unchecked) signatures.

Inherited Functions

checkSignaturesAreValid

open fun checkSignaturesAreValid(): Unit

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 verifyRequiredSignatures instead.

getMissingSigners

open fun getMissingSigners(): Set<PublicKey>

Return the PublicKeys for which we still need signatures.

verifyRequiredSignatures

open fun verifyRequiredSignatures(): Unit

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 requiredSigningKeys set.

verifySignaturesExcept

open fun verifySignaturesExcept(vararg allowedToBeMissing: PublicKey): Unit
open fun verifySignaturesExcept(allowedToBeMissing: Collection<PublicKey>): Unit

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 requiredSigningKeys set.

Extension Functions

contextLogger

fun Any.contextLogger(): Logger

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