net.corda.core.transactions / TransactionBuilder

# TransactionBuilder

`open class TransactionBuilder`

A TransactionBuilder is a transaction class thats mutable (unlike the others which are all immutable). It is intended to be passed around contracts that may edit it by adding new states/commands. Then once the states and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.

The builder can be customised for specific transaction types, e.g. where additional processing is needed before adding a state/command.

### Parameters

`notary` - Notary used for the transaction. If null, this indicates the transaction DOES NOT have a notary. When this is set to a non-null value, an output state can be added by just passing in a ContractState – a TransactionState with this notary specified will be generated automatically.
`signers` - The set of public keys the transaction needs signatures for. The logic for building the signers set can be customised for every TransactionType. E.g. in the general case it contains the command and notary public keys, but for the TransactionType.NotaryChange transactions it is the set of all input ContractState.participants.

### Constructors

<init> | `TransactionBuilder(type: TransactionType = TransactionType.General(), notary: Party? = null, inputs: MutableList<StateRef> = arrayListOf(), attachments: MutableList<SecureHash> = arrayListOf(), outputs: MutableList<TransactionState<ContractState>> = arrayListOf(), commands: MutableList<Command> = arrayListOf(), signers: MutableSet<CompositeKey> = mutableSetOf(), timestamp: Timestamp? = null)` A TransactionBuilder is a transaction class thats mutable (unlike the others which are all immutable). It is intended to be passed around contracts that may edit it by adding new states/commands. Then once the states and commands are right, this class can be used as a holding bucket to gather signatures from multiple parties.

### Properties

attachments | `val attachments: MutableList<SecureHash>`
commands | `val commands: MutableList<Command>`
currentSigs | `val currentSigs: <ERROR CLASS>` The signatures that have been collected so far - might be incomplete
inputs | `val inputs: MutableList<StateRef>`
notary | `var notary: Party?`
outputs | `val outputs: MutableList<TransactionState<ContractState>>`
signers | `val signers: MutableSet<CompositeKey>`
time | `val time: Timestamp?`
timestamp | `var timestamp: Timestamp?`
type | `val type: TransactionType`

### Functions

addAttachment | `fun addAttachment(attachmentId: SecureHash): Unit`
addCommand | `fun addCommand(arg: Command): Unit` `fun addCommand(data: CommandData, vararg keys: CompositeKey): <ERROR CLASS>` `fun addCommand(data: CommandData, keys: List<CompositeKey>): Unit`
addInputState | `open fun addInputState(stateAndRef: StateAndRef<*>): Unit`
addOutputState | `fun addOutputState(state: TransactionState<*>): Int` `fun addOutputState(state: ContractState, notary: Party): Int` `fun addOutputState(state: ContractState): Int` A default notary must be specified during builder construction to use this method
addSignatureUnchecked | `fun addSignatureUnchecked(sig: WithKey): TransactionBuilder` Adds the signature directly to the transaction, without checking it for validity.
attachments | `fun attachments(): List<SecureHash>`
checkAndAddSignature | `fun checkAndAddSignature(sig: WithKey): Unit` Checks that the given signature matches one of the commands and that it is a correct signature over the tx, then adds it.
checkSignature | `fun checkSignature(sig: WithKey): Unit` Checks that the given signature matches one of the commands and that it is a correct signature over the tx.
commands | `fun commands(): List<Command>`
copy | `fun copy(): TransactionBuilder` Creates a copy of the builder.
inputStates | `fun inputStates(): List<StateRef>`
outputStates | `fun outputStates(): List<TransactionState<*>>`
setTime | `fun setTime(time: Instant, timeTolerance: Duration): Unit` Places a TimestampCommand in this transaction, removing any existing command if there is one. The command requires a signature from the Notary service, which acts as a Timestamp Authority. The signature can be obtained using NotaryFlow. `fun setTime(newTimestamp: Timestamp): Unit`
signWith | `fun signWith(key: KeyPair): TransactionBuilder`
toSignedTransaction | `fun toSignedTransaction(checkSufficientSignatures: Boolean = true): SignedTransaction`
toWireTransaction | `fun toWireTransaction(): WireTransaction`
withItems | `fun withItems(vararg items: Any): TransactionBuilder` A more convenient way to add items to this transaction that calls the add* methods for you based on type

### Inheritors

Builder | `class Builder : TransactionBuilder` Just uses the default TransactionBuilder with no special logic
Builder | `class Builder : TransactionBuilder` A transaction builder that automatically sets the transaction type to NotaryChange and adds the list of participants to the signers set for every input state.