From 9a02a27619dcc39abd49627f62d087326ae253ec Mon Sep 17 00:00:00 2001 From: Matthew Nesbit Date: Tue, 18 Jul 2017 12:02:56 +0100 Subject: [PATCH] Add state query methods to LedgerTransaction. Update to use LedgerTransaction api Push query output logic onto BaseTransaction and update usages where possible Migrate a few more uses Address some PR comments Address some PR comments Fixup after rebase --- .../corda/core/contracts/TransactionTypes.kt | 4 +- .../core/contracts/clauses/ClauseVerifier.kt | 2 +- .../corda/core/flows/ContractUpgradeFlow.kt | 2 +- .../net/corda/core/flows/FinalityFlow.kt | 2 +- .../core/transactions/BaseTransaction.kt | 123 +++++++- .../core/transactions/LedgerTransaction.kt | 176 ++++++++++- .../core/transactions/WireTransaction.kt | 13 +- .../contracts/LedgerTransactionQueryTests.kt | 289 ++++++++++++++++++ .../contracts/TransactionEncumbranceTests.kt | 2 +- .../core/flows/CollectSignaturesFlowTests.kt | 6 +- .../core/node/AttachmentClassLoaderTests.kt | 2 +- .../kotlin/net/corda/docs/FlowCookbook.kt | 9 +- .../docs/WorkflowTransactionBuildTutorial.kt | 2 +- .../contracts/universal/UniversalContract.kt | 16 +- .../net/corda/contracts/CommercialPaper.kt | 4 +- .../corda/contracts/CommercialPaperLegacy.kt | 4 +- .../net/corda/contracts/asset/Obligation.kt | 4 +- .../main/kotlin/net/corda/flows/IssuerFlow.kt | 7 +- .../net/corda/flows/TwoPartyTradeFlow.kt | 4 +- .../net/corda/contracts/asset/CashTests.kt | 10 +- .../corda/contracts/asset/ObligationTests.kt | 10 +- .../net/corda/flows/CashExitFlowTests.kt | 2 +- .../net/corda/flows/CashIssueFlowTests.kt | 2 +- .../node/services/vault/NodeVaultService.kt | 6 +- .../corda/node/services/NotaryChangeTests.kt | 12 +- .../corda/attachmentdemo/AttachmentDemo.kt | 4 +- .../kotlin/net/corda/irs/contract/IRSTests.kt | 6 +- .../net/corda/explorer/views/Network.kt | 4 +- .../corda/explorer/views/TransactionViewer.kt | 7 +- 29 files changed, 650 insertions(+), 84 deletions(-) create mode 100644 core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt diff --git a/core/src/main/kotlin/net/corda/core/contracts/TransactionTypes.kt b/core/src/main/kotlin/net/corda/core/contracts/TransactionTypes.kt index d22eadb11f..da33d63e5d 100644 --- a/core/src/main/kotlin/net/corda/core/contracts/TransactionTypes.kt +++ b/core/src/main/kotlin/net/corda/core/contracts/TransactionTypes.kt @@ -123,7 +123,7 @@ sealed class TransactionType { */ private fun verifyContracts(tx: LedgerTransaction) { // TODO: This will all be replaced in future once the sandbox and contract constraints work is done. - val contracts = (tx.inputs.map { it.state.data.contract } + tx.outputs.map { it.data.contract }).toSet() + val contracts = (tx.inputStates.map { it.contract } + tx.outputStates.map { it.contract }).toSet() for (contract in contracts) { try { contract.verify(tx) @@ -171,6 +171,6 @@ sealed class TransactionType { } } - override fun getRequiredSigners(tx: LedgerTransaction) = tx.inputs.flatMap { it.state.data.participants }.map { it.owningKey }.toSet() + override fun getRequiredSigners(tx: LedgerTransaction) = tx.inputStates.flatMap { it.participants }.map { it.owningKey }.toSet() } } diff --git a/core/src/main/kotlin/net/corda/core/contracts/clauses/ClauseVerifier.kt b/core/src/main/kotlin/net/corda/core/contracts/clauses/ClauseVerifier.kt index db970d5f07..3583fe1779 100644 --- a/core/src/main/kotlin/net/corda/core/contracts/clauses/ClauseVerifier.kt +++ b/core/src/main/kotlin/net/corda/core/contracts/clauses/ClauseVerifier.kt @@ -23,7 +23,7 @@ fun verifyClause(tx: LedgerTransaction, Clause.log.trace("Tx ${tx.id} clause: $clause") } } - val matchedCommands = clause.verify(tx, tx.inputs.map { it.state.data }, tx.outputs.map { it.data }, commands, null) + val matchedCommands = clause.verify(tx, tx.inputStates, tx.outputStates, commands, null) check(matchedCommands.containsAll(commands.map { it.value })) { "The following commands were not matched at the end of execution: " + (commands - matchedCommands) } } diff --git a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt index 9ec39b7093..81b9657ff3 100644 --- a/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt +++ b/core/src/main/kotlin/net/corda/core/flows/ContractUpgradeFlow.kt @@ -24,7 +24,7 @@ class ContractUpgradeFlow, * overriding functions. */ protected fun extractParticipants(ltx: LedgerTransaction): List { - return ltx.outputs.flatMap { it.data.participants } + ltx.inputs.flatMap { it.state.data.participants } + return ltx.outputStates.flatMap { it.participants } + ltx.inputStates.flatMap { it.participants } } /** diff --git a/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt index 876efdda82..896fead8be 100644 --- a/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt +++ b/core/src/main/kotlin/net/corda/core/transactions/BaseTransaction.kt @@ -2,8 +2,10 @@ package net.corda.core.transactions import net.corda.core.contracts.* import net.corda.core.identity.Party +import net.corda.core.indexOfOrThrow import java.security.PublicKey import java.util.* +import java.util.function.Predicate /** * An abstract class defining fields shared by all transaction types in the system. @@ -56,4 +58,123 @@ abstract class BaseTransaction( override fun hashCode() = Objects.hash(notary, mustSign, type, timeWindow) override fun toString(): String = "${javaClass.simpleName}(id=$id)" -} + + /** + * Returns a [StateAndRef] for the given output index. + */ + @Suppress("UNCHECKED_CAST") + fun outRef(index: Int): StateAndRef = StateAndRef(outputs[index] as TransactionState, StateRef(id, index)) + + + /** + * Returns a [StateAndRef] for the requested output state, or throws [IllegalArgumentException] if not found. + */ + fun outRef(state: ContractState): StateAndRef = outRef(outputStates.indexOfOrThrow(state)) + + /** + * Helper property to return a list of [ContractState] objects, rather than the often less convenient [TransactionState] + */ + val outputStates: List get() = outputs.map { it.data } + + /** + * Helper to simplify getting an indexed output. + * @param index the position of the item in the output. + * @return The ContractState at the requested index + */ + fun getOutput(index: Int): ContractState = outputs[index].data + + /** + * Helper to simplify getting all output states of a particular class, interface, or base class. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the possibly empty list of output states matching the clazz restriction. + */ + fun outputsOfType(clazz: Class): List { + @Suppress("UNCHECKED_CAST") + return outputs.filter { clazz.isInstance(it.data) }.map { it.data as T } + } + + /** + * Helper to simplify filtering outputs according to a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the possibly empty list of output states matching the predicate and clazz restrictions. + */ + fun filterOutputs(predicate: Predicate, clazz: Class): List { + return outputsOfType(clazz).filter { predicate.test(it) } + } + + /** + * Helper to simplify finding a single output matching a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if this is the desired item. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the single item matching the predicate. + * @throws IllegalArgumentException if no item, or multiple items are found matching the requirements. + */ + fun findOutput(predicate: Predicate, clazz: Class): T { + return filterOutputs(predicate, clazz).single() + } + + /** + * Helper to simplify getting all output [StateAndRef] items of a particular state class, interface, or base class. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the possibly empty list of output [StateAndRef] states matching the clazz restriction. + */ + fun outRefsOfType(clazz: Class): List> { + @Suppress("UNCHECKED_CAST") + return outputs.mapIndexed { index, state -> StateAndRef(state, StateRef(id, index)) } + .filter { clazz.isInstance(it.state.data) } + .map { it as StateAndRef } + } + + /** + * Helper to simplify filtering output [StateAndRef] items according to a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the possibly empty list of output [StateAndRef] states matching the predicate and clazz restrictions. + */ + fun filterOutRefs(predicate: Predicate, clazz: Class): List> { + return outRefsOfType(clazz).filter { predicate.test(it.state.data) } + } + + /** + * Helper to simplify finding a single output [StateAndRef] matching a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if this is the desired item. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * Clazz must be an extension of [ContractState]. + * @return the single [StateAndRef] item matching the predicate. + * @throws IllegalArgumentException if no item, or multiple items are found matching the requirements. + */ + fun findOutRef(predicate: Predicate, clazz: Class): StateAndRef { + return filterOutRefs(predicate, clazz).single() + } + + //Kotlin extension methods to take advantage of Kotlin's smart type inference when querying the LedgerTransaction + inline fun outputsOfType(): List = this.outputsOfType(T::class.java) + + inline fun filterOutputs(crossinline predicate: (T) -> Boolean): List { + return filterOutputs(Predicate { predicate(it) }, T::class.java) + } + + inline fun findOutput(crossinline predicate: (T) -> Boolean): T { + return findOutput(Predicate { predicate(it) }, T::class.java) + } + + inline fun outRefsOfType(): List> = this.outRefsOfType(T::class.java) + + inline fun filterOutRefs(crossinline predicate: (T) -> Boolean): List> { + return filterOutRefs(Predicate { predicate(it) }, T::class.java) + } + + inline fun findOutRef(crossinline predicate: (T) -> Boolean): StateAndRef { + return findOutRef(Predicate { predicate(it) }, T::class.java) + } +} \ No newline at end of file diff --git a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt index c00c93b6ae..dd370b6e6c 100644 --- a/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt +++ b/core/src/main/kotlin/net/corda/core/transactions/LedgerTransaction.kt @@ -6,6 +6,7 @@ import net.corda.core.identity.Party import net.corda.core.serialization.CordaSerializable import java.security.PublicKey import java.util.* +import java.util.function.Predicate /** * A LedgerTransaction is derived from a [WireTransaction]. It is the result of doing the following operations: @@ -42,8 +43,15 @@ class LedgerTransaction( checkInvariants() } + val inputStates: List get() = inputs.map { it.state.data } + + /** + * Returns the typed input StateAndRef at the specified index + * @param index The index into the inputs. + * @return The [StateAndRef] + */ @Suppress("UNCHECKED_CAST") - fun outRef(index: Int) = StateAndRef(outputs[index] as TransactionState, StateRef(id, index)) + fun inRef(index: Int) = inputs[index] as StateAndRef /** * Verifies this transaction and throws an exception if not valid, depending on the type. For general transactions: @@ -100,8 +108,8 @@ class LedgerTransaction( */ // DOCSTART 2 fun groupStates(ofType: Class, selector: (T) -> K): List> { - val inputs = inputs.map { it.state.data }.filterIsInstance(ofType) - val outputs = outputs.map { it.data }.filterIsInstance(ofType) + val inputs = inputsOfType(ofType) + val outputs = outputsOfType(ofType) val inGroups: Map> = inputs.groupBy(selector) val outGroups: Map> = outputs.groupBy(selector) @@ -136,4 +144,166 @@ class LedgerTransaction( // DOCSTART 3 data class InOutGroup(val inputs: List, val outputs: List, val groupingKey: K) // DOCEND 3 + + /** + * Helper to simplify getting an indexed input [ContractState]. + * @param index the position of the item in the inputs. + * @return The [StateAndRef] at the requested index + */ + fun getInput(index: Int): ContractState = inputs[index].state.data + + /** + * Helper to simplify getting all inputs states of a particular class, interface, or base class. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [ContractState]. + * @return the possibly empty list of inputs matching the clazz restriction. + */ + fun inputsOfType(clazz: Class): List { + @Suppress("UNCHECKED_CAST") + return inputs.map { it.state.data }.filterIsInstance(clazz) + } + + /** + * Helper to simplify getting all inputs states of a particular class, interface, or base class. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [ContractState]. + * @return the possibly empty list of inputs [StateAndRef] matching the clazz restriction. + */ + fun inRefsOfType(clazz: Class): List> { + @Suppress("UNCHECKED_CAST") + return inputs.filter { clazz.isInstance(it.state.data) }.map { it as StateAndRef } + } + + /** + * Helper to simplify filtering inputs according to a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [ContractState]. + * @return the possibly empty list of input states matching the predicate and clazz restrictions. + */ + fun filterInputs(predicate: Predicate, clazz: Class): List = inputsOfType(clazz).filter { predicate.test(it) } + + /** + * Helper to simplify filtering inputs according to a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [ContractState]. + * @return the possibly empty list of inputs [StateAndRef] matching the predicate and clazz restrictions. + */ + fun filterInRefs(predicate: Predicate, clazz: Class): List> = inRefsOfType(clazz).filter { predicate.test(it.state.data) } + + /** + * Helper to simplify finding a single input [ContractState] matching a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if this is the desired item. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of ContractState. + * @return the single item matching the predicate. + * @throws IllegalArgumentException if no item, or multiple items are found matching the requirements. + */ + fun findInput(predicate: Predicate, clazz: Class): T = filterInputs(predicate, clazz).single() + + /** + * Helper to simplify finding a single input matching a [Predicate]. + * @param predicate A filtering function taking a state of type T and returning true if this is the desired item. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of ContractState. + * @return the single item matching the predicate. + * @throws IllegalArgumentException if no item, or multiple items are found matching the requirements. + */ + fun findInRef(predicate: Predicate, clazz: Class): StateAndRef = filterInRefs(predicate, clazz).single() + + /** + * Helper to simplify getting an indexed command. + * @param index the position of the item in the commands. + * @return The Command at the requested index + */ + fun getCommand(index: Int): Command = Command(commands[index].value, commands[index].signers) + + /** + * Helper to simplify getting all [Command] items with a [CommandData] of a particular class, interface, or base class. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [CommandData]. + * @return the possibly empty list of commands with [CommandData] values matching the clazz restriction. + */ + fun commandsOfType(clazz: Class): List { + return commands.filter { clazz.isInstance(it.value) }.map { Command(it.value, it.signers) } + } + + /** + * Helper to simplify filtering [Command] items according to a [Predicate]. + * @param predicate A filtering function taking a [CommandData] item of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [CommandData]. + * @return the possibly empty list of [Command] items with [CommandData] values matching the predicate and clazz restrictions. + */ + fun filterCommands(predicate: Predicate, clazz: Class): List { + @Suppress("UNCHECKED_CAST") + return commandsOfType(clazz).filter { predicate.test(it.value as T) } + } + + + /** + * Helper to simplify finding a single [Command] items according to a [Predicate]. + * @param predicate A filtering function taking a [CommandData] item of type T and returning true if it should be included in the list. + * The class filtering is applied before the predicate. + * @param clazz The class type used for filtering via an [Class.isInstance] check. + * [clazz] must be an extension of [CommandData]. + * @return the [Command] item with [CommandData] values matching the predicate and clazz restrictions. + * @throws IllegalArgumentException if no items, or multiple items matched the requirements. + */ + fun findCommand(predicate: Predicate, clazz: Class): Command { + return filterCommands(predicate, clazz).single() + } + + /** + * Helper to simplify getting an indexed attachment. + * @param index the position of the item in the attachments. + * @return The Attachment at the requested index. + */ + fun getAttachment(index: Int): Attachment = attachments[index] + + /** + * Helper to simplify getting an indexed attachment. + * @param id the SecureHash of the desired attachment. + * @return The Attachment with the matching id. + * @throws IllegalArgumentException if no item matches the id. + */ + fun getAttachment(id: SecureHash): Attachment = attachments.single { it.id == id } + + //Kotlin extension methods to take advantage of Kotlin's smart type inference when querying the LedgerTransaction + inline fun inputsOfType(): List = this.inputsOfType(T::class.java) + + inline fun inRefsOfType(): List> = this.inRefsOfType(T::class.java) + + inline fun filterInputs(crossinline predicate: (T) -> Boolean): List { + return filterInputs(Predicate { predicate(it) }, T::class.java) + } + + inline fun filterInRefs(crossinline predicate: (T) -> Boolean): List> { + return filterInRefs(Predicate { predicate(it) }, T::class.java) + } + + inline fun findInRef(crossinline predicate: (T) -> Boolean): StateAndRef { + return findInRef(Predicate { predicate(it) }, T::class.java) + } + + inline fun findInput(crossinline predicate: (T) -> Boolean): T { + return findInput(Predicate { predicate(it) }, T::class.java) + } + + inline fun commandsOfType(): List = this.commandsOfType(T::class.java) + + inline fun filterCommands(crossinline predicate: (T) -> Boolean): List { + return filterCommands(Predicate { predicate(it) }, T::class.java) + } + + inline fun findCommand(crossinline predicate: (T) -> Boolean): Command { + return findCommand(Predicate { predicate(it) }, T::class.java) + } } + diff --git a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt index 6715365840..dc487f52e1 100644 --- a/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt +++ b/core/src/main/kotlin/net/corda/core/transactions/WireTransaction.kt @@ -6,12 +6,11 @@ import net.corda.core.crypto.MerkleTree import net.corda.core.crypto.SecureHash import net.corda.core.crypto.keys import net.corda.core.identity.Party -import net.corda.core.indexOfOrThrow +import net.corda.core.internal.Emoji import net.corda.core.node.ServicesForResolution import net.corda.core.serialization.* import net.corda.core.serialization.SerializationDefaults.P2P_CONTEXT import net.corda.core.serialization.SerializationDefaults.SERIALIZATION_FACTORY -import net.corda.core.internal.Emoji import java.security.PublicKey import java.security.SignatureException import java.util.function.Predicate @@ -53,16 +52,6 @@ class WireTransaction( } } - /** Returns a [StateAndRef] for the given output index. */ - @Suppress("UNCHECKED_CAST") - fun outRef(index: Int): StateAndRef { - require(index >= 0 && index < outputs.size) - return StateAndRef(outputs[index] as TransactionState, StateRef(id, index)) - } - - /** Returns a [StateAndRef] for the requested output state, or throws [IllegalArgumentException] if not found. */ - fun outRef(state: ContractState): StateAndRef = outRef(outputs.map { it.data }.indexOfOrThrow(state)) - /** * 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. diff --git a/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt b/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt new file mode 100644 index 0000000000..55b36038c6 --- /dev/null +++ b/core/src/test/kotlin/net/corda/core/contracts/LedgerTransactionQueryTests.kt @@ -0,0 +1,289 @@ +package net.corda.core.contracts + +import net.corda.core.identity.AbstractParty +import net.corda.core.node.ServiceHub +import net.corda.core.transactions.LedgerTransaction +import net.corda.core.transactions.TransactionBuilder +import net.corda.testing.DUMMY_NOTARY +import net.corda.testing.TestDependencyInjectionBase +import net.corda.testing.contracts.DummyContract +import net.corda.testing.node.MockServices +import org.junit.Before +import org.junit.Test +import java.util.function.Predicate +import kotlin.test.assertEquals +import kotlin.test.assertFailsWith +import kotlin.test.assertTrue + +class LedgerTransactionQueryTests : TestDependencyInjectionBase() { + + private lateinit var services: ServiceHub + + @Before + fun setup() { + services = MockServices() + } + + interface Commands { + data class Cmd1(val id: Int) : CommandData, Commands + data class Cmd2(val id: Int) : CommandData, Commands + } + + + private class StringTypeDummyState(val data: String) : ContractState { + override val contract: Contract = DummyContract() + override val participants: List = emptyList() + } + + private class IntTypeDummyState(val data: Int) : ContractState { + override val contract: Contract = DummyContract() + override val participants: List = emptyList() + } + + private fun makeDummyState(data: Any): ContractState { + return when (data) { + is String -> StringTypeDummyState(data) + is Int -> IntTypeDummyState(data) + else -> throw IllegalArgumentException() + } + } + + private fun makeDummyStateAndRef(data: Any): StateAndRef<*> { + val dummyState = makeDummyState(data) + val fakeIssueTx = services.signInitialTransaction(TransactionBuilder(notary = DUMMY_NOTARY).addOutputState(dummyState)) + services.recordTransactions(fakeIssueTx) + val dummyStateRef = StateRef(fakeIssueTx.id, 0) + return StateAndRef(TransactionState(dummyState, DUMMY_NOTARY, null), dummyStateRef) + } + + private fun makeDummyTransaction(): LedgerTransaction { + val tx = TransactionBuilder(notary = DUMMY_NOTARY) + for (i in 0..4) { + tx.addInputState(makeDummyStateAndRef(i)) + tx.addInputState(makeDummyStateAndRef(i.toString())) + tx.addOutputState(makeDummyState(i)) + tx.addOutputState(makeDummyState(i.toString())) + tx.addCommand(Commands.Cmd1(i), listOf(services.myInfo.legalIdentity.owningKey)) + tx.addCommand(Commands.Cmd2(i), listOf(services.myInfo.legalIdentity.owningKey)) + } + return tx.toLedgerTransaction(services) + } + + @Test + fun `Simple InRef Indexer tests`() { + val ltx = makeDummyTransaction() + assertEquals(0, ltx.inRef(0).state.data.data) + assertEquals("0", ltx.inRef(1).state.data.data) + assertEquals(3, ltx.inRef(6).state.data.data) + assertEquals("3", ltx.inRef(7).state.data.data) + assertFailsWith { ltx.inRef(10) } + } + + @Test + fun `Simple OutRef Indexer tests`() { + val ltx = makeDummyTransaction() + assertEquals(0, ltx.outRef(0).state.data.data) + assertEquals("0", ltx.outRef(1).state.data.data) + assertEquals(3, ltx.outRef(6).state.data.data) + assertEquals("3", ltx.outRef(7).state.data.data) + assertFailsWith { ltx.outRef(10) } + } + + @Test + fun `Simple Input Indexer tests`() { + val ltx = makeDummyTransaction() + assertEquals(0, (ltx.getInput(0) as IntTypeDummyState).data) + assertEquals("0", (ltx.getInput(1) as StringTypeDummyState).data) + assertEquals(3, (ltx.getInput(6) as IntTypeDummyState).data) + assertEquals("3", (ltx.getInput(7) as StringTypeDummyState).data) + assertFailsWith { ltx.getInput(10) } + } + + @Test + fun `Simple Output Indexer tests`() { + val ltx = makeDummyTransaction() + assertEquals(0, (ltx.getOutput(0) as IntTypeDummyState).data) + assertEquals("0", (ltx.getOutput(1) as StringTypeDummyState).data) + assertEquals(3, (ltx.getOutput(6) as IntTypeDummyState).data) + assertEquals("3", (ltx.getOutput(7) as StringTypeDummyState).data) + assertFailsWith { ltx.getOutput(10) } + } + + @Test + fun `Simple Command Indexer tests`() { + val ltx = makeDummyTransaction() + assertEquals(0, (ltx.getCommand(0).value as Commands.Cmd1).id) + assertEquals(0, (ltx.getCommand(1).value as Commands.Cmd2).id) + assertEquals(3, (ltx.getCommand(6).value as Commands.Cmd1).id) + assertEquals(3, (ltx.getCommand(7).value as Commands.Cmd2).id) + assertFailsWith { ltx.getOutput(10) } + } + + @Test + fun `Simple Inputs of type tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.inputsOfType(IntTypeDummyState::class.java) + assertEquals(5, intStates.size) + assertEquals(listOf(0, 1, 2, 3, 4), intStates.map { it.data }) + val stringStates = ltx.inputsOfType() + assertEquals(5, stringStates.size) + assertEquals(listOf("0", "1", "2", "3", "4"), stringStates.map { it.data }) + val notPresentQuery = ltx.inputsOfType(FungibleAsset::class.java) + assertEquals(emptyList(), notPresentQuery) + } + + @Test + fun `Simple InputsRefs of type tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.inRefsOfType(IntTypeDummyState::class.java) + assertEquals(5, intStates.size) + assertEquals(listOf(0, 1, 2, 3, 4), intStates.map { it.state.data.data }) + assertEquals(listOf(ltx.inputs[0], ltx.inputs[2], ltx.inputs[4], ltx.inputs[6], ltx.inputs[8]), intStates) + val stringStates = ltx.inRefsOfType() + assertEquals(5, stringStates.size) + assertEquals(listOf("0", "1", "2", "3", "4"), stringStates.map { it.state.data.data }) + assertEquals(listOf(ltx.inputs[1], ltx.inputs[3], ltx.inputs[5], ltx.inputs[7], ltx.inputs[9]), stringStates) + } + + @Test + fun `Simple Outputs of type tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.outputsOfType(IntTypeDummyState::class.java) + assertEquals(5, intStates.size) + assertEquals(listOf(0, 1, 2, 3, 4), intStates.map { it.data }) + val stringStates = ltx.outputsOfType() + assertEquals(5, stringStates.size) + assertEquals(listOf("0", "1", "2", "3", "4"), stringStates.map { it.data }) + val notPresentQuery = ltx.outputsOfType(FungibleAsset::class.java) + assertEquals(emptyList(), notPresentQuery) + } + + @Test + fun `Simple OutputsRefs of type tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.outRefsOfType(IntTypeDummyState::class.java) + assertEquals(5, intStates.size) + assertEquals(listOf(0, 1, 2, 3, 4), intStates.map { it.state.data.data }) + assertEquals(listOf(0, 2, 4, 6, 8), intStates.map { it.ref.index }) + assertTrue(intStates.all { it.ref.txhash == ltx.id }) + val stringStates = ltx.outRefsOfType() + assertEquals(5, stringStates.size) + assertEquals(listOf("0", "1", "2", "3", "4"), stringStates.map { it.state.data.data }) + assertEquals(listOf(1, 3, 5, 7, 9), stringStates.map { it.ref.index }) + assertTrue(stringStates.all { it.ref.txhash == ltx.id }) + } + + @Test + fun `Simple Commands of type tests`() { + val ltx = makeDummyTransaction() + val intCmd1 = ltx.commandsOfType(Commands.Cmd1::class.java) + assertEquals(5, intCmd1.size) + assertEquals(listOf(0, 1, 2, 3, 4), intCmd1.map { (it.value as Commands.Cmd1).id }) + val intCmd2 = ltx.commandsOfType() + assertEquals(5, intCmd2.size) + assertEquals(listOf(0, 1, 2, 3, 4), intCmd2.map { (it.value as Commands.Cmd2).id }) + val notPresentQuery = ltx.commandsOfType(FungibleAsset.Commands.Exit::class.java) + assertEquals(emptyList(), notPresentQuery) + } + + @Test + fun `Filtered Input Tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.filterInputs(Predicate { it.data.rem(2) == 0 }, IntTypeDummyState::class.java) + assertEquals(3, intStates.size) + assertEquals(listOf(0, 2, 4), intStates.map { it.data }) + val stringStates: List = ltx.filterInputs { it.data == "3" } + assertEquals("3", stringStates.single().data) + } + + @Test + fun `Filtered InRef Tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.filterInRefs(Predicate { it.data.rem(2) == 0 }, IntTypeDummyState::class.java) + assertEquals(3, intStates.size) + assertEquals(listOf(0, 2, 4), intStates.map { it.state.data.data }) + assertEquals(listOf(ltx.inputs[0], ltx.inputs[4], ltx.inputs[8]), intStates) + val stringStates: List> = ltx.filterInRefs { it.data == "3" } + assertEquals("3", stringStates.single().state.data.data) + assertEquals(ltx.inputs[7], stringStates.single()) + } + + @Test + fun `Filtered Output Tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.filterOutputs(Predicate { it.data.rem(2) == 0 }, IntTypeDummyState::class.java) + assertEquals(3, intStates.size) + assertEquals(listOf(0, 2, 4), intStates.map { it.data }) + val stringStates: List = ltx.filterOutputs { it.data == "3" } + assertEquals("3", stringStates.single().data) + } + + @Test + fun `Filtered OutRef Tests`() { + val ltx = makeDummyTransaction() + val intStates = ltx.filterOutRefs(Predicate { it.data.rem(2) == 0 }, IntTypeDummyState::class.java) + assertEquals(3, intStates.size) + assertEquals(listOf(0, 2, 4), intStates.map { it.state.data.data }) + assertEquals(listOf(0, 4, 8), intStates.map { it.ref.index }) + assertTrue(intStates.all { it.ref.txhash == ltx.id }) + val stringStates: List> = ltx.filterOutRefs { it.data == "3" } + assertEquals("3", stringStates.single().state.data.data) + assertEquals(7, stringStates.single().ref.index) + assertEquals(ltx.id, stringStates.single().ref.txhash) + } + + @Test + fun `Filtered Commands Tests`() { + val ltx = makeDummyTransaction() + val intCmds1 = ltx.filterCommands(Predicate { it.id.rem(2) == 0 }, Commands.Cmd1::class.java) + assertEquals(3, intCmds1.size) + assertEquals(listOf(0, 2, 4), intCmds1.map { (it.value as Commands.Cmd1).id }) + val intCmds2 = ltx.filterCommands { it.id == 3 } + assertEquals(3, (intCmds2.single().value as Commands.Cmd2).id) + } + + @Test + fun `Find Input Tests`() { + val ltx = makeDummyTransaction() + val intState = ltx.findInput(Predicate { it.data == 4 }, IntTypeDummyState::class.java) + assertEquals(ltx.getInput(8), intState) + val stringState: StringTypeDummyState = ltx.findInput { it.data == "3" } + assertEquals(ltx.getInput(7), stringState) + } + + @Test + fun `Find InRef Tests`() { + val ltx = makeDummyTransaction() + val intState = ltx.findInRef(Predicate { it.data == 4 }, IntTypeDummyState::class.java) + assertEquals(ltx.inRef(8), intState) + val stringState: StateAndRef = ltx.findInRef { it.data == "3" } + assertEquals(ltx.inRef(7), stringState) + } + + @Test + fun `Find Output Tests`() { + val ltx = makeDummyTransaction() + val intState = ltx.findOutput(Predicate { it.data == 4 }, IntTypeDummyState::class.java) + assertEquals(ltx.getOutput(8), intState) + val stringState: StringTypeDummyState = ltx.findOutput { it.data == "3" } + assertEquals(ltx.getOutput(7), stringState) + } + + @Test + fun `Find OutRef Tests`() { + val ltx = makeDummyTransaction() + val intState = ltx.findOutRef(Predicate { it.data == 4 }, IntTypeDummyState::class.java) + assertEquals(ltx.outRef(8), intState) + val stringState: StateAndRef = ltx.findOutRef { it.data == "3" } + assertEquals(ltx.outRef(7), stringState) + } + + @Test + fun `Find Commands Tests`() { + val ltx = makeDummyTransaction() + val intCmd1 = ltx.findCommand(Predicate { it.id == 2 }, Commands.Cmd1::class.java) + assertEquals(ltx.getCommand(4), intCmd1) + val intCmd2 = ltx.findCommand { it.id == 3 } + assertEquals(ltx.getCommand(7), intCmd2) + } +} \ No newline at end of file diff --git a/core/src/test/kotlin/net/corda/core/contracts/TransactionEncumbranceTests.kt b/core/src/test/kotlin/net/corda/core/contracts/TransactionEncumbranceTests.kt index 7352579be3..2d05c6ea3d 100644 --- a/core/src/test/kotlin/net/corda/core/contracts/TransactionEncumbranceTests.kt +++ b/core/src/test/kotlin/net/corda/core/contracts/TransactionEncumbranceTests.kt @@ -29,7 +29,7 @@ class TransactionEncumbranceTests { class DummyTimeLock : Contract { override val legalContractReference = SecureHash.sha256("DummyTimeLock") override fun verify(tx: LedgerTransaction) { - val timeLockInput = tx.inputs.map { it.state.data }.filterIsInstance().singleOrNull() ?: return + val timeLockInput = tx.inputsOfType().singleOrNull() ?: return val time = tx.timeWindow?.untilTime ?: throw IllegalArgumentException("Transactions containing time-locks must have a time-window") requireThat { "the time specified in the time-lock has passed" using (time >= timeLockInput.validFrom) diff --git a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt index a322952e49..22bce20926 100644 --- a/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt +++ b/core/src/test/kotlin/net/corda/core/flows/CollectSignaturesFlowTests.kt @@ -61,9 +61,10 @@ class CollectSignaturesFlowTests { val flow = object : SignTransactionFlow(otherParty) { @Suspendable override fun checkTransaction(stx: SignedTransaction) = requireThat { val tx = stx.tx + val ltx = tx.toLedgerTransaction(serviceHub) "There should only be one output state" using (tx.outputs.size == 1) "There should only be one output state" using (tx.inputs.isEmpty()) - val magicNumberState = tx.outputs.single().data as DummyContract.MultiOwnerState + val magicNumberState = ltx.outputsOfType().single() "Must be 1337 or greater" using (magicNumberState.magicNumber >= 1337) } } @@ -118,9 +119,10 @@ class CollectSignaturesFlowTests { val flow = object : SignTransactionFlow(otherParty) { @Suspendable override fun checkTransaction(stx: SignedTransaction) = requireThat { val tx = stx.tx + val ltx = tx.toLedgerTransaction(serviceHub) "There should only be one output state" using (tx.outputs.size == 1) "There should only be one output state" using (tx.inputs.isEmpty()) - val magicNumberState = tx.outputs.single().data as DummyContract.MultiOwnerState + val magicNumberState = ltx.outputsOfType().single() "Must be 1337 or greater" using (magicNumberState.magicNumber >= 1337) } } diff --git a/core/src/test/kotlin/net/corda/core/node/AttachmentClassLoaderTests.kt b/core/src/test/kotlin/net/corda/core/node/AttachmentClassLoaderTests.kt index 33d64c768d..3e2e54096a 100644 --- a/core/src/test/kotlin/net/corda/core/node/AttachmentClassLoaderTests.kt +++ b/core/src/test/kotlin/net/corda/core/node/AttachmentClassLoaderTests.kt @@ -295,7 +295,7 @@ class AttachmentClassLoaderTests : TestDependencyInjectionBase() { } val copiedWireTransaction = bytes.deserialize(context = context) assertEquals(1, copiedWireTransaction.outputs.size) - val contract2 = copiedWireTransaction.outputs[0].data.contract as DummyContractBackdoor + val contract2 = copiedWireTransaction.getOutput(0).contract as DummyContractBackdoor assertEquals(42, contract2.inspectState(copiedWireTransaction.outputs[0].data)) } diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt index 88d9e05d6b..46550b3c15 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/FlowCookbook.kt @@ -12,10 +12,7 @@ import net.corda.core.node.services.ServiceType import net.corda.core.node.services.Vault.Page import net.corda.core.node.services.queryBy import net.corda.core.node.services.vault.QueryCriteria.VaultQueryCriteria -import net.corda.core.transactions.LedgerTransaction -import net.corda.core.transactions.SignedTransaction -import net.corda.core.transactions.TransactionBuilder -import net.corda.core.transactions.WireTransaction +import net.corda.core.transactions.* import net.corda.core.utilities.ProgressTracker import net.corda.core.utilities.ProgressTracker.Step import net.corda.core.utilities.UntrustworthyData @@ -416,7 +413,7 @@ object FlowCookbook { // sign it! We need to make sure the transaction represents an // agreement we actually want to enter into. // DOCSTART 34 - val outputState: DummyState = wireTx.outputs.single().data as DummyState + val outputState: DummyState = wireTx.outputsOfType().single() if (outputState.magicNumber == 777) { // ``FlowException`` is a special exception type. It will be // propagated back to any counterparty flows waiting for a @@ -548,7 +545,7 @@ object FlowCookbook { val signTransactionFlow: SignTransactionFlow = object : SignTransactionFlow(counterparty) { override fun checkTransaction(stx: SignedTransaction) = requireThat { // Any additional checking we see fit... - val outputState = stx.tx.outputs.single().data as DummyState + val outputState = stx.tx.outputsOfType().single() assert(outputState.magicNumber == 777) } } diff --git a/docs/source/example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt b/docs/source/example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt index c80e7a52cf..8be1f3a8be 100644 --- a/docs/source/example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt +++ b/docs/source/example-code/src/main/kotlin/net/corda/docs/WorkflowTransactionBuildTutorial.kt @@ -79,7 +79,7 @@ data class TradeApprovalContract(override val legalContractReference: SecureHash "Issue of new WorkflowContract must not include any inputs" using (tx.inputs.isEmpty()) "Issue of new WorkflowContract must be in a unique transaction" using (tx.outputs.size == 1) } - val issued = tx.outputs[0].data as TradeApprovalContract.State + val issued = tx.outputsOfType().single() requireThat { "Issue requires the source Party as signer" using (command.signers.contains(issued.source.owningKey)) "Initial Issue state must be NEW" using (issued.state == WorkflowState.NEW) diff --git a/experimental/src/main/kotlin/net/corda/contracts/universal/UniversalContract.kt b/experimental/src/main/kotlin/net/corda/contracts/universal/UniversalContract.kt index 33f94b3bc4..0e695837ef 100644 --- a/experimental/src/main/kotlin/net/corda/contracts/universal/UniversalContract.kt +++ b/experimental/src/main/kotlin/net/corda/contracts/universal/UniversalContract.kt @@ -192,7 +192,7 @@ class UniversalContract : Contract { when (value) { is Commands.Action -> { - val inState = tx.inputs.single().state.data as State + val inState = tx.inputsOfType().single() val arr = when (inState.details) { is Actions -> inState.details is RollOut -> reduceRollOut(inState.details) @@ -222,7 +222,7 @@ class UniversalContract : Contract { when (tx.outputs.size) { 1 -> { - val outState = tx.outputs.single().data as State + val outState = tx.outputsOfType().single() requireThat { "output state must match action result state" using (arrangement.equals(outState.details)) "output state must match action result state" using (rest == zero) @@ -230,7 +230,7 @@ class UniversalContract : Contract { } 0 -> throw IllegalArgumentException("must have at least one out state") else -> { - val allContracts = And(tx.outputs.map { (it.data as State).details }.toSet()) + val allContracts = And(tx.outputsOfType().map { it.details }.toSet()) requireThat { "output states must match action result state" using (arrangement.equals(allContracts)) @@ -240,15 +240,15 @@ class UniversalContract : Contract { } } is Commands.Issue -> { - val outState = tx.outputs.single().data as State + val outState = tx.outputsOfType().single() requireThat { "the transaction is signed by all liable parties" using (liableParties(outState.details).all { it in cmd.signers }) "the transaction has no input states" using tx.inputs.isEmpty() } } is Commands.Move -> { - val inState = tx.inputs.single().state.data as State - val outState = tx.outputs.single().data as State + val inState = tx.inputsOfType().single() + val outState = tx.outputsOfType().single() requireThat { "the transaction is signed by all liable parties" using (liableParties(outState.details).all { it in cmd.signers }) @@ -257,13 +257,13 @@ class UniversalContract : Contract { } } is Commands.Fix -> { - val inState = tx.inputs.single().state.data as State + val inState = tx.inputsOfType().single() val arr = when (inState.details) { is Actions -> inState.details is RollOut -> reduceRollOut(inState.details) else -> throw IllegalArgumentException("Unexpected arrangement, " + tx.inputs.single()) } - val outState = tx.outputs.single().data as State + val outState = tx.outputsOfType().single() val unusedFixes = value.fixes.map { it.of }.toMutableSet() val expectedArr = replaceFixing(tx, arr, diff --git a/finance/src/main/kotlin/net/corda/contracts/CommercialPaper.kt b/finance/src/main/kotlin/net/corda/contracts/CommercialPaper.kt index c0b31b72c2..0320ed785a 100644 --- a/finance/src/main/kotlin/net/corda/contracts/CommercialPaper.kt +++ b/finance/src/main/kotlin/net/corda/contracts/CommercialPaper.kt @@ -13,13 +13,13 @@ import net.corda.core.crypto.random63BitValue import net.corda.core.crypto.toBase58String import net.corda.core.identity.AbstractParty import net.corda.core.identity.Party +import net.corda.core.internal.Emoji import net.corda.core.node.services.VaultService import net.corda.core.schemas.MappedSchema import net.corda.core.schemas.PersistentState import net.corda.core.schemas.QueryableState import net.corda.core.transactions.LedgerTransaction import net.corda.core.transactions.TransactionBuilder -import net.corda.core.internal.Emoji import net.corda.schemas.CommercialPaperSchemaV1 import java.time.Instant import java.util.* @@ -172,7 +172,7 @@ class CommercialPaper : Contract { val timeWindow = tx.timeWindow val input = inputs.single() - val received = tx.outputs.map { it.data }.sumCashBy(input.owner) + val received = tx.outputStates.sumCashBy(input.owner) val time = timeWindow?.fromTime ?: throw IllegalArgumentException("Redemptions must have a time-window") requireThat { "the paper must have matured" using (time >= input.maturityDate) diff --git a/finance/src/main/kotlin/net/corda/contracts/CommercialPaperLegacy.kt b/finance/src/main/kotlin/net/corda/contracts/CommercialPaperLegacy.kt index 5648959ac6..b53246d25b 100644 --- a/finance/src/main/kotlin/net/corda/contracts/CommercialPaperLegacy.kt +++ b/finance/src/main/kotlin/net/corda/contracts/CommercialPaperLegacy.kt @@ -7,10 +7,10 @@ import net.corda.core.crypto.SecureHash import net.corda.core.crypto.testing.NULL_PARTY import net.corda.core.identity.AbstractParty import net.corda.core.identity.Party +import net.corda.core.internal.Emoji import net.corda.core.node.services.VaultService import net.corda.core.transactions.LedgerTransaction import net.corda.core.transactions.TransactionBuilder -import net.corda.core.internal.Emoji import java.time.Instant import java.util.* @@ -81,7 +81,7 @@ class CommercialPaperLegacy : Contract { is Commands.Redeem -> { // Redemption of the paper requires movement of on-ledger cash. val input = inputs.single() - val received = tx.outputs.map { it.data }.sumCashBy(input.owner) + val received = tx.outputStates.sumCashBy(input.owner) val time = timeWindow?.fromTime ?: throw IllegalArgumentException("Redemptions must have a time-window") requireThat { "the paper must have matured" using (time >= input.maturityDate) diff --git a/finance/src/main/kotlin/net/corda/contracts/asset/Obligation.kt b/finance/src/main/kotlin/net/corda/contracts/asset/Obligation.kt index b0b06973bb..7fef1625ea 100644 --- a/finance/src/main/kotlin/net/corda/contracts/asset/Obligation.kt +++ b/finance/src/main/kotlin/net/corda/contracts/asset/Obligation.kt @@ -14,10 +14,10 @@ import net.corda.core.crypto.random63BitValue import net.corda.core.identity.AbstractParty import net.corda.core.identity.AnonymousParty import net.corda.core.identity.Party +import net.corda.core.internal.Emoji import net.corda.core.serialization.CordaSerializable import net.corda.core.transactions.LedgerTransaction import net.corda.core.transactions.TransactionBuilder -import net.corda.core.internal.Emoji import net.corda.core.utilities.NonEmptySet import net.corda.core.utilities.seconds import org.bouncycastle.asn1.x500.X500Name @@ -159,7 +159,7 @@ class Obligation

: Contract { // Move (signed by B) // // That would pass this check. Ensuring they do not is best addressed in the transaction generation stage. - val assetStates = tx.outputs.map { it.data }.filterIsInstance>() + val assetStates = tx.outputsOfType>() val acceptableAssetStates = assetStates // TODO: This filter is nonsense, because it just checks there is an asset contract loaded, we need to // verify the asset contract is the asset contract we expect. diff --git a/finance/src/main/kotlin/net/corda/flows/IssuerFlow.kt b/finance/src/main/kotlin/net/corda/flows/IssuerFlow.kt index 72d11fe0c7..ccd6001fdf 100644 --- a/finance/src/main/kotlin/net/corda/flows/IssuerFlow.kt +++ b/finance/src/main/kotlin/net/corda/flows/IssuerFlow.kt @@ -6,8 +6,8 @@ import net.corda.core.contracts.* import net.corda.core.flows.* import net.corda.core.identity.Party import net.corda.core.serialization.CordaSerializable -import net.corda.core.utilities.OpaqueBytes import net.corda.core.transactions.SignedTransaction +import net.corda.core.utilities.OpaqueBytes import net.corda.core.utilities.ProgressTracker import net.corda.core.utilities.unwrap import java.util.* @@ -49,10 +49,7 @@ object IssuerFlow { return sendAndReceive(issuerBankParty, issueRequest).unwrap { res -> val tx = res.stx.tx val expectedAmount = Amount(amount.quantity, Issued(issuerBankParty.ref(issueToPartyRef), amount.token)) - val cashOutputs = tx.outputs - .map { it.data} - .filterIsInstance() - .filter { state -> state.owner == res.recipient } + val cashOutputs = tx.filterOutputs { state -> state.owner == res.recipient } require(cashOutputs.size == 1) { "Require a single cash output paying ${res.recipient}, found ${tx.outputs}" } require(cashOutputs.single().amount == expectedAmount) { "Require payment of $expectedAmount"} res diff --git a/finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt b/finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt index 1290536405..b03c655c3f 100644 --- a/finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt +++ b/finance/src/main/kotlin/net/corda/flows/TwoPartyTradeFlow.kt @@ -8,11 +8,11 @@ import net.corda.core.identity.AbstractParty import net.corda.core.identity.AnonymousParty import net.corda.core.identity.Party import net.corda.core.node.NodeInfo -import net.corda.core.utilities.seconds import net.corda.core.serialization.CordaSerializable import net.corda.core.transactions.SignedTransaction import net.corda.core.transactions.TransactionBuilder import net.corda.core.utilities.ProgressTracker +import net.corda.core.utilities.seconds import net.corda.core.utilities.unwrap import java.security.PublicKey import java.util.* @@ -85,7 +85,7 @@ object TwoPartyTradeFlow { // DOCSTART 5 val signTransactionFlow = object : SignTransactionFlow(otherParty, VERIFYING_AND_SIGNING.childProgressTracker()) { override fun checkTransaction(stx: SignedTransaction) { - if (stx.tx.outputs.map { it.data }.sumCashBy(me).withoutIssuer() != price) + if (stx.tx.outputStates.sumCashBy(me).withoutIssuer() != price) throw FlowException("Transaction is not sending us the right amount of cash") } } diff --git a/finance/src/test/kotlin/net/corda/contracts/asset/CashTests.kt b/finance/src/test/kotlin/net/corda/contracts/asset/CashTests.kt index 04518c251f..a0d5fbc242 100644 --- a/finance/src/test/kotlin/net/corda/contracts/asset/CashTests.kt +++ b/finance/src/test/kotlin/net/corda/contracts/asset/CashTests.kt @@ -159,7 +159,7 @@ class CashTests : TestDependencyInjectionBase() { Cash().generateIssue(this, 100.DOLLARS `issued by` MINI_CORP.ref(12, 34), owner = AnonymousParty(DUMMY_PUBKEY_1), notary = DUMMY_NOTARY) }.toWireTransaction() assertTrue(tx.inputs.isEmpty()) - val s = tx.outputs[0].data as Cash.State + val s = tx.outputsOfType().single() assertEquals(100.DOLLARS `issued by` MINI_CORP.ref(12, 34), s.amount) assertEquals(MINI_CORP as AbstractParty, s.amount.token.issuer.party) assertEquals(AnonymousParty(DUMMY_PUBKEY_1), s.owner) @@ -514,7 +514,7 @@ class CashTests : TestDependencyInjectionBase() { val wtx = makeExit(50.DOLLARS, MEGA_CORP, 1) assertEquals(WALLET[0].ref, wtx.inputs[0]) assertEquals(1, wtx.outputs.size) - assertEquals(WALLET[0].state.data.copy(amount = WALLET[0].state.data.amount.splitEvenly(2).first()), wtx.outputs[0].data) + assertEquals(WALLET[0].state.data.copy(amount = WALLET[0].state.data.amount.splitEvenly(2).first()), wtx.getOutput(0)) } /** @@ -574,7 +574,7 @@ class CashTests : TestDependencyInjectionBase() { @Suppress("UNCHECKED_CAST") val vaultState = vaultStatesUnconsumed.elementAt(0) assertEquals(vaultState.ref, wtx.inputs[0]) - assertEquals(vaultState.state.data.copy(owner = THEIR_IDENTITY_1), wtx.outputs[0].data) + assertEquals(vaultState.state.data.copy(owner = THEIR_IDENTITY_1), wtx.getOutput(0)) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } @@ -618,7 +618,7 @@ class CashTests : TestDependencyInjectionBase() { val vaultState1 = vaultStatesUnconsumed.elementAt(1) assertEquals(vaultState0.ref, wtx.inputs[0]) assertEquals(vaultState1.ref, wtx.inputs[1]) - assertEquals(vaultState0.state.data.copy(owner = THEIR_IDENTITY_1, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.outputs[0].data) + assertEquals(vaultState0.state.data.copy(owner = THEIR_IDENTITY_1, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.getOutput(0)) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } @@ -639,7 +639,7 @@ class CashTests : TestDependencyInjectionBase() { assertEquals(vaultState1.ref, wtx.inputs[1]) assertEquals(vaultState2.ref, wtx.inputs[2]) assertEquals(vaultState0.state.data.copy(owner = THEIR_IDENTITY_1, amount = 500.DOLLARS `issued by` defaultIssuer), wtx.outputs[1].data) - assertEquals(vaultState2.state.data.copy(owner = THEIR_IDENTITY_1), wtx.outputs[0].data) + assertEquals(vaultState2.state.data.copy(owner = THEIR_IDENTITY_1), wtx.getOutput(0)) assertEquals(OUR_IDENTITY_1.owningKey, wtx.commands.single { it.value is Cash.Commands.Move }.signers[0]) } } diff --git a/finance/src/test/kotlin/net/corda/contracts/asset/ObligationTests.kt b/finance/src/test/kotlin/net/corda/contracts/asset/ObligationTests.kt index e9f19c4db4..cc2ed93af0 100644 --- a/finance/src/test/kotlin/net/corda/contracts/asset/ObligationTests.kt +++ b/finance/src/test/kotlin/net/corda/contracts/asset/ObligationTests.kt @@ -146,7 +146,7 @@ class ObligationTests { beneficiary = CHARLIE, template = megaCorpDollarSettlement ) - assertEquals(tx.outputs[0].data, expected) + assertEquals(tx.getOutput(0), expected) assertTrue(tx.commands[0].value is Obligation.Commands.Issue) assertEquals(MINI_CORP_PUBKEY, tx.commands[0].signers[0]) resetTestSerialization() @@ -250,7 +250,7 @@ class ObligationTests { }.toWireTransaction() assertEquals(1, tx.outputs.size) - val actual = tx.outputs[0].data + val actual = tx.getOutput(0) assertEquals((1000000.DOLLARS `issued by` defaultIssuer).OBLIGATION between Pair(ALICE, BOB), actual) } @@ -277,7 +277,7 @@ class ObligationTests { }.toWireTransaction() assertEquals(1, tx.outputs.size) val expected = obligationBobToAlice.copy(quantity = obligationBobToAlice.quantity - obligationAliceToBob.quantity) - val actual = tx.outputs[0].data + val actual = tx.getOutput(0) assertEquals(expected, actual) } @@ -305,7 +305,7 @@ class ObligationTests { stx = notaryServices.addSignature(ptx) assertEquals(1, stx.tx.outputs.size) - assertEquals(stateAndRef.state.data.copy(lifecycle = Lifecycle.DEFAULTED), stx.tx.outputs[0].data) + assertEquals(stateAndRef.state.data.copy(lifecycle = Lifecycle.DEFAULTED), stx.tx.getOutput(0)) stx.verifyRequiredSignatures() // And set it back @@ -316,7 +316,7 @@ class ObligationTests { ptx = miniCorpServices.signInitialTransaction(tx) stx = notaryServices.addSignature(ptx) assertEquals(1, stx.tx.outputs.size) - assertEquals(stateAndRef.state.data.copy(lifecycle = Lifecycle.NORMAL), stx.tx.outputs[0].data) + assertEquals(stateAndRef.state.data.copy(lifecycle = Lifecycle.NORMAL), stx.tx.getOutput(0)) stx.verifyRequiredSignatures() } diff --git a/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt b/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt index 9ed4a335ed..7809764116 100644 --- a/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt +++ b/finance/src/test/kotlin/net/corda/flows/CashExitFlowTests.kt @@ -55,7 +55,7 @@ class CashExitFlowTests { val expected = (initialBalance - exitAmount).`issued by`(bankOfCorda.ref(ref)) assertEquals(1, exitTx.inputs.size) assertEquals(1, exitTx.outputs.size) - val output = exitTx.outputs.map { it.data }.filterIsInstance().single() + val output = exitTx.outputsOfType().single() assertEquals(expected, output.amount) } diff --git a/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt b/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt index 36f0edddd4..c94ca63492 100644 --- a/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt +++ b/finance/src/test/kotlin/net/corda/flows/CashIssueFlowTests.kt @@ -47,7 +47,7 @@ class CashIssueFlowTests { notary)).resultFuture mockNet.runNetwork() val issueTx = future.getOrThrow().stx - val output = issueTx.tx.outputs.single().data as Cash.State + val output = issueTx.tx.outputsOfType().single() assertEquals(expected.`issued by`(bankOfCorda.ref(ref)), output.amount) } diff --git a/node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt b/node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt index 2e436f1a95..773772ad5f 100644 --- a/node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt +++ b/node/src/main/kotlin/net/corda/node/services/vault/NodeVaultService.kt @@ -457,7 +457,7 @@ class NodeVaultService(private val services: ServiceHub, dataSourceProperties: P // Retrieve unspent and unlocked cash states that meet our spending criteria. val acceptableCoins = unconsumedStatesForSpending(amount, onlyFromParties, tx.notary, tx.lockId) return OnLedgerAsset.generateSpend(tx, amount, to, acceptableCoins, - { state, amount, owner -> deriveState(state, amount, owner) }, + { state, quantity, owner -> deriveState(state, quantity, owner) }, { Cash().generateMoveCommand() }) } @@ -466,9 +466,7 @@ class NodeVaultService(private val services: ServiceHub, dataSourceProperties: P @VisibleForTesting internal fun makeUpdate(tx: WireTransaction, ourKeys: Set): Vault.Update { - val ourNewStates = tx.outputs. - filter { isRelevant(it.data, ourKeys) }. - map { tx.outRef(it.data) } + val ourNewStates = tx.filterOutRefs { isRelevant(it, ourKeys) } // Retrieve all unconsumed states for this transaction's inputs val consumedStates = HashSet>() diff --git a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt index 7aeadcf487..1f1cdc48bf 100644 --- a/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt +++ b/node/src/test/kotlin/net/corda/node/services/NotaryChangeTests.kt @@ -1,19 +1,19 @@ package net.corda.node.services import net.corda.core.contracts.* -import net.corda.testing.contracts.DummyContract import net.corda.core.crypto.generateKeyPair +import net.corda.core.flows.NotaryChangeFlow +import net.corda.core.flows.StateReplacementException import net.corda.core.getOrThrow import net.corda.core.identity.Party import net.corda.core.node.services.ServiceInfo -import net.corda.core.utilities.seconds import net.corda.core.transactions.WireTransaction -import net.corda.core.flows.NotaryChangeFlow -import net.corda.core.flows.StateReplacementException +import net.corda.core.utilities.seconds import net.corda.node.internal.AbstractNode import net.corda.node.services.network.NetworkMapService import net.corda.node.services.transactions.SimpleNotaryService import net.corda.testing.DUMMY_NOTARY +import net.corda.testing.contracts.DummyContract import net.corda.testing.getTestPartyAndCertificate import net.corda.testing.node.MockNetwork import org.assertj.core.api.Assertions.assertThatExceptionOfType @@ -109,8 +109,8 @@ class NotaryChangeTests { val notaryChangeTx = clientNodeA.services.validatedTransactions.getTransaction(newState.ref.txhash)!!.tx // Check that all encumbrances have been propagated to the outputs - val originalOutputs = issueTx.outputs.map { it.data } - val newOutputs = notaryChangeTx.outputs.map { it.data } + val originalOutputs = issueTx.outputStates + val newOutputs = notaryChangeTx.outputStates assertTrue(originalOutputs.minus(newOutputs).isEmpty()) // Check that encumbrance links aren't broken after notary change diff --git a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt index 120dc3680c..7fab70f1e1 100644 --- a/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt +++ b/samples/attachment-demo/src/main/kotlin/net/corda/attachmentdemo/AttachmentDemo.kt @@ -125,7 +125,7 @@ fun recipient(rpc: CordaRPCOps) { val wtx = stx.tx if (wtx.attachments.isNotEmpty()) { if (wtx.outputs.isNotEmpty()) { - val state = wtx.outputs.map { it.data }.filterIsInstance().single() + val state = wtx.outputsOfType().single() require(rpc.attachmentExists(state.hash)) // Download the attachment via the Web endpoint. @@ -173,7 +173,7 @@ class AttachmentContract : Contract { get() = SecureHash.zeroHash // TODO not implemented override fun verify(tx: LedgerTransaction) { - val state = tx.outputs.map { it.data }.filterIsInstance().single() + val state = tx.outputsOfType().single() val attachment = tx.attachments.single() require(state.hash == attachment.id) } diff --git a/samples/irs-demo/src/test/kotlin/net/corda/irs/contract/IRSTests.kt b/samples/irs-demo/src/test/kotlin/net/corda/irs/contract/IRSTests.kt index ce7e0b17ef..b068329b61 100644 --- a/samples/irs-demo/src/test/kotlin/net/corda/irs/contract/IRSTests.kt +++ b/samples/irs-demo/src/test/kotlin/net/corda/irs/contract/IRSTests.kt @@ -2,8 +2,8 @@ package net.corda.irs.contract import net.corda.contracts.* import net.corda.core.contracts.* -import net.corda.core.utilities.seconds import net.corda.core.transactions.SignedTransaction +import net.corda.core.utilities.seconds import net.corda.testing.* import net.corda.testing.node.MockServices import org.junit.Test @@ -246,7 +246,7 @@ class IRSTests : TestDependencyInjectionBase() { * Utility so I don't have to keep typing this. */ fun singleIRS(irsSelector: Int = 1): InterestRateSwap.State { - return generateIRSTxn(irsSelector).tx.outputs.map { it.data }.filterIsInstance().single() + return generateIRSTxn(irsSelector).tx.outputsOfType().single() } /** @@ -300,7 +300,7 @@ class IRSTests : TestDependencyInjectionBase() { var previousTXN = generateIRSTxn(1) previousTXN.toLedgerTransaction(services).verify() services.recordTransactions(previousTXN) - fun currentIRS() = previousTXN.tx.outputs.map { it.data }.filterIsInstance().single() + fun currentIRS() = previousTXN.tx.outputsOfType().single() while (true) { val nextFix: FixOf = currentIRS().nextFixingOf() ?: break diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/views/Network.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/views/Network.kt index 44e08e45b2..b3d07e6363 100644 --- a/tools/explorer/src/main/kotlin/net/corda/explorer/views/Network.kt +++ b/tools/explorer/src/main/kotlin/net/corda/explorer/views/Network.kt @@ -27,8 +27,8 @@ import javafx.util.Duration import net.corda.client.jfx.model.* import net.corda.client.jfx.utils.* import net.corda.core.contracts.ContractState -import net.corda.core.identity.Party import net.corda.core.crypto.toBase58String +import net.corda.core.identity.Party import net.corda.core.node.NodeInfo import net.corda.explorer.formatters.PartyNameFormatter import net.corda.explorer.model.CordaView @@ -77,7 +77,7 @@ class Network : CordaView() { .map { it as? PartiallyResolvedTransaction.InputResolution.Resolved } .filterNotNull() .map { it.stateAndRef.state.data }.getParties() - val outputParties = it.transaction.tx.outputs.map { it.data }.observable().getParties() + val outputParties = it.transaction.tx.outputStates.observable().getParties() val signingParties = it.transaction.sigs.map { getModel().lookup(it.by) } // Input parties fire a bullets to all output parties, and to the signing parties. !! This is a rough guess of how the message moves in the network. // TODO : Expose artemis queue to get real message information. diff --git a/tools/explorer/src/main/kotlin/net/corda/explorer/views/TransactionViewer.kt b/tools/explorer/src/main/kotlin/net/corda/explorer/views/TransactionViewer.kt index 858117de3f..ae8a6252e7 100644 --- a/tools/explorer/src/main/kotlin/net/corda/explorer/views/TransactionViewer.kt +++ b/tools/explorer/src/main/kotlin/net/corda/explorer/views/TransactionViewer.kt @@ -22,7 +22,10 @@ import net.corda.client.jfx.utils.map import net.corda.client.jfx.utils.sequence import net.corda.contracts.asset.Cash import net.corda.core.contracts.* -import net.corda.core.crypto.* +import net.corda.core.crypto.SecureHash +import net.corda.core.crypto.commonName +import net.corda.core.crypto.toBase58String +import net.corda.core.crypto.toStringShort import net.corda.core.identity.AbstractParty import net.corda.core.node.NodeInfo import net.corda.explorer.AmountDiff @@ -124,7 +127,7 @@ class TransactionViewer : CordaView("Transactions") { totalValueEquiv = ::calculateTotalEquiv.lift(myIdentity, reportingExchange, resolved.map { it.state.data }.lift(), - it.transaction.tx.outputs.map { it.data }.lift()) + it.transaction.tx.outputStates.lift()) ) }