CODEWITHSUNDEEP
corda
Joel
Joel

Reputation: 23140

Can a Corda transaction reference a state as an input without consuming it?

In Corda, is there a way to refer to an unspent state in a transaction without spending it? The aim is to allow the contract to use some of the information in the state being referred to as part of the verify method.

Upvotes: 3

Views: 1271

Answers (2)

Joel
Joel

Reputation: 23140

There is no built-in support for this pattern in Corda at this time, but it will be added in Corda 4 (see Roger's answer below). For now, you have several options:

Writing the states' contracts to allow this behaviour:

You can add a command to the contract which enforces the requirement that there is a matching output for each input of the state type you wish to reference. This guarantees that the transaction is only referencing the state, and not modifying it. Here is an example:

class MyContract : Contract {
    override fun verify(tx: LedgerTransaction) {
        val command = tx.commands.requireSingleCommand<MyContract.Commands>()
        when (command.value) {
            is Commands.Reference -> requireThat {
                val inputs = tx.inputsOfType<MyState>()
                val outputs = tx.outputsOfType<MyState>()
                // Assuming `MyState.equals` has been overridden appropriately.
                "There must be a matching output state for each input state" using
                        (inputs.toSet() == outputs.toSet())
            }
        }
    }

    interface Commands : CommandData {
        class Reference: Commands
    }
}

Referring the state as a field in an input state, output state or command:

You can include the reference state in the transaction as a field on an input state, output state or command. A command is likely to be the best fit:

interface Commands : CommandData {
    class Reference(val referenceState: MyState): Commands
}

You can then check the contents of this state within the contract's verify method. For example:

class MyContract : Contract {
    override fun verify(tx: LedgerTransaction) {
        val command = tx.commands.requireSingleCommand<MyContract.Commands>()
        when (command.value) {
            is Commands.Reference -> requireThat {
                val commandData = command.value as Commands.Reference
                val referenceState = commandData.referenceStateAndRef.state.data
                val inputs = tx.inputsOfType<MyState>()
                "The input state contents must match the reference data" using
                        (inputs.all { it.contents == referenceState.contents })
            }
        }
    }

    interface Commands : CommandData {
        class Reference(val referenceStateAndRef: StateAndRef<MyState>): Commands
    }
}

With this approach, you also have to check in the flow that the reference state is identical to the state actually on the ledger (i.e. that the transaction's proposer hasn't added a fake state object as a reference). For example:

val referenceCommand = ledgerTransaction.commandsOfType<Reference>().single()
val referenceStateAndRef = referenceCommand.value.referenceStateAndRef
val actualStateAndRefFromVault = serviceHub.toStateAndRef<MyState>(referenceStateRef)
if (referenceStateAndRef != actualStateAndRefFromVault) {
    throw FlowException("Referenced state does not match state in the vault.")
}

Upvotes: 1

Roger Willis
Roger Willis

Reputation: 922

Reference states will be added to Corda Version 4 which will be released later this year. This solves the problem above. See:

https://github.com/corda/corda/blob/master/docs/source/design/reference-states/design.md

Upvotes: 4

Related Questions