Split CashFlow into three flows

Split CashFlow into independent CashIssueFlow, CashExitFlow and CashPaymentFlow,
so that users can be given access to one but not the other(s).

Signed-off-by: Ross Nicoll <ross.nicoll@r3.com>

node/src/integration-test/kotlin/net/corda/node/services/DistributedServiceTests.kt

@@ -11,8 +11,9 @@ import net.corda.core.messaging.StateMachineUpdate
 import net.corda.core.messaging.startFlow
 import net.corda.core.node.NodeInfo
 import net.corda.core.serialization.OpaqueBytes
-import net.corda.flows.CashCommand
-import net.corda.flows.CashFlow
+import net.corda.core.transactions.SignedTransaction
+import net.corda.flows.CashIssueFlow
+import net.corda.flows.CashPaymentFlow
 import net.corda.node.driver.DriverBasedTest
 import net.corda.node.driver.NodeHandle
 import net.corda.node.driver.driver
@@ -35,7 +36,10 @@ class DistributedServiceTests : DriverBasedTest() {
     override fun setup() = driver {
         // Start Alice and 3 notaries in a RAFT cluster
         val clusterSize = 3
-        val testUser = User("test", "test", permissions = setOf(startFlowPermission<CashFlow>()))
+        val testUser = User("test", "test", permissions = setOf(
+                startFlowPermission<CashIssueFlow>(),
+                startFlowPermission<CashPaymentFlow>())
+        )
         val aliceFuture = startNode("Alice", rpcUsers = listOf(testUser))
         val notariesFuture = startNotaryCluster(
                 "Notary",
@@ -135,15 +139,15 @@ class DistributedServiceTests : DriverBasedTest() {
 
     private fun issueCash(amount: Amount<Currency>) {
         val issueHandle = aliceProxy.startFlow(
-                ::CashFlow,
-                CashCommand.IssueCash(amount, OpaqueBytes.of(0), alice.nodeInfo.legalIdentity, raftNotaryIdentity))
+                ::CashIssueFlow,
+                amount, OpaqueBytes.of(0), alice.nodeInfo.legalIdentity, raftNotaryIdentity)
         issueHandle.returnValue.getOrThrow()
     }
 
     private fun paySelf(amount: Amount<Currency>) {
         val payHandle = aliceProxy.startFlow(
-                ::CashFlow,
-                CashCommand.PayCash(amount.issuedBy(alice.nodeInfo.legalIdentity.ref(0)), alice.nodeInfo.legalIdentity))
+                ::CashPaymentFlow,
+                amount.issuedBy(alice.nodeInfo.legalIdentity.ref(0)), alice.nodeInfo.legalIdentity)
         payHandle.returnValue.getOrThrow()
     }
-}
+}

node/src/main/kotlin/net/corda/node/internal/AbstractNode.kt

@@ -6,6 +6,8 @@ import com.google.common.util.concurrent.ListenableFuture
 import com.google.common.util.concurrent.MoreExecutors
 import com.google.common.util.concurrent.SettableFuture
 import net.corda.core.*
+import net.corda.core.contracts.Amount
+import net.corda.core.contracts.PartyAndReference
 import net.corda.core.crypto.Party
 import net.corda.core.crypto.X509Utilities
 import net.corda.core.flows.FlowLogic
@@ -16,14 +18,12 @@ import net.corda.core.messaging.SingleMessageRecipient
 import net.corda.core.node.*
 import net.corda.core.node.services.*
 import net.corda.core.node.services.NetworkMapCache.MapChange
+import net.corda.core.serialization.OpaqueBytes
 import net.corda.core.serialization.SingletonSerializeAsToken
 import net.corda.core.serialization.deserialize
 import net.corda.core.serialization.serialize
 import net.corda.core.transactions.SignedTransaction
-import net.corda.flows.CashCommand
-import net.corda.flows.CashFlow
-import net.corda.flows.FinalityFlow
-import net.corda.flows.sendRequest
+import net.corda.flows.*
 import net.corda.node.services.api.*
 import net.corda.node.services.config.NodeConfiguration
 import net.corda.node.services.config.configureWithDevSSLCertificate
@@ -51,7 +51,6 @@ import net.corda.node.utilities.databaseTransaction
 import org.apache.activemq.artemis.utils.ReusableLatch
 import org.jetbrains.exposed.sql.Database
 import org.slf4j.Logger
-import java.io.File
 import java.nio.file.FileAlreadyExistsException
 import java.nio.file.Path
 import java.security.KeyPair
@@ -82,11 +81,12 @@ abstract class AbstractNode(open val configuration: NodeConfiguration,
         val PUBLIC_IDENTITY_FILE_NAME = "identity-public"
 
         val defaultFlowWhiteList: Map<Class<out FlowLogic<*>>, Set<Class<*>>> = mapOf(
-                CashFlow::class.java to setOf(
-                        CashCommand.IssueCash::class.java,
-                        CashCommand.PayCash::class.java,
-                        CashCommand.ExitCash::class.java
-                ),
+                CashFlow::class.java to setOf(CashFlow.Command.IssueCash::class.java,
+                        CashFlow.Command.PayCash::class.java,
+                        CashFlow.Command.ExitCash::class.java),
+                CashExitFlow::class.java to setOf(Amount::class.java, PartyAndReference::class.java),
+                CashIssueFlow::class.java to setOf(Amount::class.java, OpaqueBytes::class.java, Party::class.java),
+                CashPaymentFlow::class.java to setOf(Amount::class.java, Party::class.java),
                 FinalityFlow::class.java to emptySet()
         )
     }

node/src/test/kotlin/net/corda/node/CordaRPCOpsImplTest.kt

@@ -9,8 +9,8 @@ import net.corda.core.node.services.ServiceInfo
 import net.corda.core.node.services.Vault
 import net.corda.core.serialization.OpaqueBytes
 import net.corda.core.transactions.SignedTransaction
-import net.corda.flows.CashCommand
-import net.corda.flows.CashFlow
+import net.corda.flows.CashIssueFlow
+import net.corda.flows.CashPaymentFlow
 import net.corda.node.internal.CordaRPCOpsImpl
 import net.corda.node.services.User
 import net.corda.node.services.messaging.CURRENT_RPC_USER
@@ -48,7 +48,10 @@ class CordaRPCOpsImplTest {
         aliceNode = network.createNode(networkMapAddress = networkMap.info.address)
         notaryNode = network.createNode(advertisedServices = ServiceInfo(SimpleNotaryService.type), networkMapAddress = networkMap.info.address)
         rpc = CordaRPCOpsImpl(aliceNode.services, aliceNode.smm, aliceNode.database)
-        CURRENT_RPC_USER.set(User("user", "pwd", permissions = setOf(startFlowPermission<CashFlow>())))
+        CURRENT_RPC_USER.set(User("user", "pwd", permissions = setOf(
+                startFlowPermission<CashIssueFlow>(),
+                startFlowPermission<CashPaymentFlow>()
+        )))
 
         databaseTransaction(aliceNode.database) {
             stateMachineUpdates = rpc.stateMachinesAndUpdates().second
@@ -69,8 +72,7 @@ class CordaRPCOpsImplTest {
 
         // Tell the monitoring service node to issue some cash
         val recipient = aliceNode.info.legalIdentity
-        val outEvent = CashCommand.IssueCash(Amount(quantity, GBP), ref, recipient, notaryNode.info.notaryIdentity)
-        rpc.startFlow(::CashFlow, outEvent)
+        rpc.startFlow(::CashIssueFlow, Amount(quantity, GBP), ref, recipient, notaryNode.info.notaryIdentity)
         network.runNetwork()
 
         val expectedState = Cash.State(Amount(quantity,
@@ -107,19 +109,19 @@ class CordaRPCOpsImplTest {
     @Test
     fun `issue and move`() {
 
-        rpc.startFlow(::CashFlow, CashCommand.IssueCash(
-                amount = Amount(100, USD),
-                issueRef = OpaqueBytes(ByteArray(1, { 1 })),
-                recipient = aliceNode.info.legalIdentity,
-                notary = notaryNode.info.notaryIdentity
-        ))
+        rpc.startFlow(::CashIssueFlow,
+                Amount(100, USD),
+                OpaqueBytes(ByteArray(1, { 1 })),
+                aliceNode.info.legalIdentity,
+                notaryNode.info.notaryIdentity
+        )
 
         network.runNetwork()
 
-        rpc.startFlow(::CashFlow, CashCommand.PayCash(
-                amount = Amount(100, Issued(PartyAndReference(aliceNode.info.legalIdentity, OpaqueBytes(ByteArray(1, { 1 }))), USD)),
-                recipient = aliceNode.info.legalIdentity
-        ))
+        rpc.startFlow(::CashPaymentFlow,
+                Amount(100, Issued(PartyAndReference(aliceNode.info.legalIdentity, OpaqueBytes(ByteArray(1, { 1 }))), USD)),
+                aliceNode.info.legalIdentity
+        )
 
         network.runNetwork()
 
@@ -188,12 +190,12 @@ class CordaRPCOpsImplTest {
     fun `cash command by user not permissioned for cash`() {
         CURRENT_RPC_USER.set(User("user", "pwd", permissions = emptySet()))
         assertThatExceptionOfType(PermissionException::class.java).isThrownBy {
-            rpc.startFlow(::CashFlow, CashCommand.IssueCash(
-                    amount = Amount(100, USD),
-                    issueRef = OpaqueBytes(ByteArray(1, { 1 })),
-                    recipient = aliceNode.info.legalIdentity,
-                    notary = notaryNode.info.notaryIdentity
-            ))
+            rpc.startFlow(::CashIssueFlow,
+                    Amount(100, USD),
+                    OpaqueBytes(ByteArray(1, { 1 })),
+                    aliceNode.info.legalIdentity,
+                    notaryNode.info.notaryIdentity
+            )
         }
     }
 }

node/src/test/kotlin/net/corda/node/services/statemachine/StateMachineManagerTests.kt

@@ -24,8 +24,8 @@ import net.corda.core.serialization.deserialize
 import net.corda.core.utilities.unwrap
 import net.corda.core.transactions.SignedTransaction
 import net.corda.core.transactions.TransactionBuilder
-import net.corda.flows.CashCommand
-import net.corda.flows.CashFlow
+import net.corda.flows.CashIssueFlow
+import net.corda.flows.CashPaymentFlow
 import net.corda.flows.FinalityFlow
 import net.corda.flows.NotaryFlow
 import net.corda.node.services.persistence.checkpoints
@@ -320,16 +320,16 @@ class StateMachineManagerTests {
     @Test
     fun `different notaries are picked when addressing shared notary identity`() {
         assertEquals(notary1.info.notaryIdentity, notary2.info.notaryIdentity)
-        node1.services.startFlow(CashFlow(CashCommand.IssueCash(
+        node1.services.startFlow(CashIssueFlow(
                 DOLLARS(2000),
                 OpaqueBytes.of(0x01),
                 node1.info.legalIdentity,
-                notary1.info.notaryIdentity)))
+                notary1.info.notaryIdentity))
         // We pay a couple of times, the notary picking should go round robin
         for (i in 1 .. 3) {
-            node1.services.startFlow(CashFlow(CashCommand.PayCash(
+            node1.services.startFlow(CashPaymentFlow(
                     DOLLARS(500).issuedBy(node1.info.legalIdentity.ref(0x01)),
-                    node2.info.legalIdentity)))
+                    node2.info.legalIdentity))
             net.runNetwork()
         }
         val endpoint = net.messagingNetwork.endpoint(notary1.net.myAddress as InMemoryMessagingNetwork.PeerHandle)!!