Added manual settlement rail

.gitignore

@@ -22,7 +22,7 @@ lib/dokka.jar
 *.iml
 
 ## Directory-based project format:
-#.idea
+.idea/
 
 # if you remove the above rule, at least ignore the following:
 
@@ -58,6 +58,10 @@ lib/dokka.jar
 /out/
 cordapp/out/
 cordapp-contracts-states/out/
+oracle/out/
+ripple/out/
+swift/out/
+manual/out/
 
 # mpeltonen/sbt-idea plugin
 .idea_modules/

build.gradle

@@ -1,7 +1,7 @@
 buildscript {
     ext.corda_release_group = 'net.corda'
     ext.corda_release_version = '4.1-RC03'
-    ext.corda_gradle_plugins_version = '4.0.42'
+    ext.corda_gradle_plugins_version = '4.0.44'
     ext.kotlin_version = '1.2.51'
     ext.junit_version = '4.12'
     ext.quasar_version = '0.7.9'
@@ -10,6 +10,7 @@ buildscript {
         jcenter()
         mavenCentral()
         mavenLocal()
+        maven { url "http://ci-artifactory.corda.r3cev.com/artifactory/corda-releases" }
     }
 
     dependencies {
@@ -124,6 +125,8 @@ dependencies {
     testCompile project(path: ':cordapp', configuration: 'testOutput')
 }
 
+jar.enabled = false
+
 task integrationTest(type: Test, dependsOn: []) {
     testClassesDirs = sourceSets.integrationTest.output.classesDirs
     classpath = sourceSets.integrationTest.runtimeClasspath

cordapp-contracts-states/src/main/kotlin/com/r3/corda/finance/obligation/commands/ObligationCommands.kt

@@ -7,6 +7,7 @@ import com.r3.corda.sdk.token.contracts.types.TokenType
 import net.corda.core.contracts.Amount
 import net.corda.core.contracts.CommandData
 import net.corda.core.contracts.TypeOnlyCommandData
+import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.identity.AbstractParty
 import net.corda.core.identity.Party
 import java.time.Instant
@@ -59,5 +60,5 @@ interface ObligationCommands : CommandData {
     data class UpdatePayment(val ref: PaymentReference) : ObligationCommands
 
     /** Cancel the obligation - involves exiting the obligation state from the ledger. */
-    class Cancel : ObligationCommands, TypeOnlyCommandData()
+    data class Cancel(val id: UniqueIdentifier) : ObligationCommands, TypeOnlyCommandData()
 }

cordapp-contracts-states/src/main/kotlin/com/r3/corda/finance/obligation/states/Obligation.kt

@@ -1,10 +1,12 @@
 package com.r3.corda.finance.obligation.states
 
+import com.r3.corda.finance.obligation.contracts.ObligationContract
 import com.r3.corda.finance.obligation.types.Payment
 import com.r3.corda.finance.obligation.types.PaymentStatus
 import com.r3.corda.finance.obligation.types.SettlementMethod
 import com.r3.corda.sdk.token.contracts.types.TokenType
 import net.corda.core.contracts.Amount
+import net.corda.core.contracts.BelongsToContract
 import net.corda.core.contracts.LinearState
 import net.corda.core.contracts.UniqueIdentifier
 import net.corda.core.crypto.toStringShort
@@ -33,6 +35,8 @@ import java.time.Instant
  * 8. Obligations are considered in default if they are not fully paid by the dueDate, if one is specified.
  *
  */
+
+@BelongsToContract(ObligationContract::class)
 data class Obligation<T : TokenType>(
         /** Obligations are always denominated in some token type as we need a reference for FX purposes. */
         val faceAmount: Amount<T>,

cordapp-contracts-states/src/main/kotlin/com/r3/corda/finance/obligation/types/SettlementMethod.kt

@@ -29,8 +29,8 @@ data class FxRate(val baseCurrency: TokenType, val counterCurrency: TokenType, v
  * The obligation could be denominated in GBP but the payment could be made in XRP.
  */
 interface OffLedgerPayment<T : AbstractMakeOffLedgerPayment> : SettlementMethod {
-    /** The Oracle used to determine if payment is made. */
-    val settlementOracle: Party
+    /** The Oracle used to determine if payment is made. Use null for manual payment verification */
+    val settlementOracle: Party?
     /** The flow used to initiate the off-ledger payment. */
     val paymentFlow: Class<T>
 }

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/DummyContract.kt

@@ -0,0 +1,8 @@
+package com.r3.corda.finance.obligation.client
+
+import net.corda.core.contracts.Contract
+import net.corda.core.transactions.LedgerTransaction
+
+class DummyContract : Contract {
+    override fun verify(tx: LedgerTransaction) = Unit
+}

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/CancelObligation.kt

@@ -53,7 +53,7 @@ object CancelObligation {
             val signers = obligation.participants.map { it.owningKey }
             val utx = TransactionBuilder(notary = notary).apply {
                 addInputState(obligationStateAndRef)
-                addCommand(ObligationCommands.Cancel(), signers)
+                addCommand(ObligationCommands.Cancel(obligation.linearId), signers)
             }
 
             // Get the counterparty and our signing key.
@@ -69,18 +69,17 @@ object CancelObligation {
 
             // Get the counterparty's signature.
             progressTracker.currentStep = COLLECTING
-            val couterpartyFlow = initiateFlow(counterparty as Party)
+            val counterpartyFlow = initiateFlow(counterparty as Party)
             val stx = subFlow(CollectSignaturesFlow(
                     partiallySignedTx = ptx,
-                    sessionsToCollectFrom = setOf(couterpartyFlow),
+                    sessionsToCollectFrom = setOf(counterpartyFlow),
                     myOptionalKeys = listOf(us.owningKey),
                     progressTracker = COLLECTING.childProgressTracker()
             ))
 
             progressTracker.currentStep = FINALISING
-            return subFlow(FinalityFlow(stx, FINALISING.childProgressTracker()))
+            return subFlow(FinalityFlow(stx, setOf(counterpartyFlow), FINALISING.childProgressTracker()))
         }
-
     }
 
     @InitiatedBy(Initiator::class)
@@ -96,10 +95,7 @@ object CancelObligation {
                 }
             }
             val stx = subFlow(flow)
-            // Suspend this flow until the transaction is committed.
-            return waitForLedgerCommit(stx.id)
+            return subFlow(ReceiveFinalityFlow(otherSession, stx.id))
         }
-
     }
-
 }

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/CreateObligation.kt

@@ -58,9 +58,9 @@ object CreateObligation {
         override val progressTracker: ProgressTracker = tracker()
 
         @Suspendable
-        private fun createAnonymousObligation(): Pair<Obligation<T>, PublicKey> {
-            // TODO: Update to use the new confidential identities constrcutor.
-            val txKeys = subFlow(SwapIdentitiesFlow(counterparty))
+        private fun createAnonymousObligation(lenderFlow: FlowSession): Pair<Obligation<T>, PublicKey> {
+	    // TODO: Update to use the new confidential identities constructor.
+            val txKeys = subFlow(SwapIdentitiesFlow(lenderFlow))
             // SwapIdentityFlow should return two keys.
             check(txKeys.size == 2) { "Something went wrong when generating confidential identities." }
             val anonymousMe = txKeys[ourIdentity] ?: throw FlowException("Couldn't create our conf. identity.")
@@ -82,8 +82,9 @@ object CreateObligation {
         override fun call(): WireTransaction {
             // Step 1. Initialisation.
             progressTracker.currentStep = INITIALISING
+            val lenderFlow = initiateFlow(counterparty)
             val (obligation, signingKey) = if (anonymous) {
-                createAnonymousObligation()
+                createAnonymousObligation(lenderFlow)
             } else {
                 createObligation(us = ourIdentity, them = counterparty)
             }
@@ -113,7 +114,6 @@ object CreateObligation {
 
             // Step 5. Get the counterparty signature.
             progressTracker.currentStep = COLLECTING
-            val lenderFlow = initiateFlow(counterparty)
             val stx = subFlow(CollectSignaturesFlow(
                     partiallySignedTx = ptx,
                     sessionsToCollectFrom = setOf(lenderFlow),
@@ -123,8 +123,7 @@ object CreateObligation {
 
             // Step 6. Finalise and return the transaction.
             progressTracker.currentStep = FINALISING
-            // TODO: Update to use teh new FinalityFlow constructor throughout.
-            val ntx = subFlow(FinalityFlow(stx, FINALISING.childProgressTracker()))
+            val ntx = subFlow(FinalityFlow(stx, setOf(lenderFlow), FINALISING.childProgressTracker()))
             return ntx.tx
         }
     }
@@ -142,7 +141,7 @@ object CreateObligation {
             }
             val stx = subFlow(flow)
             // Suspend this flow until the transaction is committed.
-            return waitForLedgerCommit(stx.id).tx
+            return subFlow(ReceiveFinalityFlow(otherFlow, stx.id)).tx
         }
     }
-}
+}

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/MakeOffLedgerPayment.kt

@@ -24,7 +24,7 @@ abstract class MakeOffLedgerPayment<T : TokenType>(
         object CHECKING : ProgressTracker.Step("Checking balance.")
         object PAYING : ProgressTracker.Step("Making payment.")
         object UPDATING : ProgressTracker.Step("Updating obligation with payment details.") {
-            override fun childProgressTracker() = UpdateObligationWithPayment.tracker()
+            override fun childProgressTracker() = UpdateObligationWithPayment.Initiator.tracker()
         }
 
         fun tracker() = ProgressTracker(SETUP, CHECKING, PAYING, UPDATING)
@@ -63,7 +63,7 @@ abstract class MakeOffLedgerPayment<T : TokenType>(
 
         // 5. Add payment reference to settlement instructions and update state.
         progressTracker.currentStep = UPDATING
-        return subFlow(UpdateObligationWithPayment(
+        return subFlow(UpdateObligationWithPayment.Initiator(
                 linearId = obligation.linearId,
                 paymentInformation = paymentInformation,
                 progressTracker = UPDATING.childProgressTracker()

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/NovateObligation.kt

@@ -26,7 +26,7 @@ object NovateObligation {
     @StartableByRPC
     class Initiator(
             val linearId: UniqueIdentifier,
-            val novationCommand: ObligationCommands.Novate
+            private val novationCommand: ObligationCommands.Novate
     ) : FlowLogic<WireTransaction>() {
 
         companion object {
@@ -126,16 +126,16 @@ object NovateObligation {
 
             // Get the counterparty's signature.
             progressTracker.currentStep = COLLECTING
-            val couterpartyFlow = initiateFlow(counterparty as Party)
+            val counterpartyFlow = initiateFlow(counterparty as Party)
             val stx = subFlow(CollectSignaturesFlow(
                     partiallySignedTx = ptx,
-                    sessionsToCollectFrom = setOf(couterpartyFlow),
+                    sessionsToCollectFrom = setOf(counterpartyFlow),
                     myOptionalKeys = listOf(us.owningKey),
                     progressTracker = COLLECTING.childProgressTracker()
             ))
 
             progressTracker.currentStep = FINALISING
-            return subFlow(FinalityFlow(stx, FINALISING.childProgressTracker())).tx
+            return subFlow(FinalityFlow(stx, setOf(counterpartyFlow), FINALISING.childProgressTracker())).tx
         }
     }
 
@@ -151,8 +151,7 @@ object NovateObligation {
                 }
             }
             val stx = subFlow(flow)
-            // Suspend this flow until the transaction is committed.
-            return waitForLedgerCommit(stx.id).tx
+            return subFlow(ReceiveFinalityFlow(otherFlow, stx.id)).tx
         }
     }
 

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/OffLedgerSettleObligation.kt

@@ -73,13 +73,14 @@ class OffLedgerSettleObligation<T : TokenType>(
         progressTracker.currentStep = PAYING
         when (settlementMethod) {
             is OnLedgerSettlement -> throw IllegalStateException("ObligationContract to be settled on-ledger. Aborting...")
-            is OffLedgerPayment<*> -> subFlow(getFlowInstance(settlementMethod, obligationStateAndRef, PAYING.childProgressTracker()))
+            is OffLedgerPayment<*> -> {
+                val tx = subFlow(getFlowInstance(settlementMethod, obligationStateAndRef, PAYING.childProgressTracker()))
+                // Checks the payment settled only if settlementOracle != null
+                // We only supply the linear ID because this flow can be called from the shell on its own.
+                return if (settlementMethod.settlementOracle == null) tx.tx
+                else subFlow(SendToSettlementOracle(linearId, SENDING.childProgressTracker())).tx
+            }
             else -> throw IllegalStateException("No settlement instructions added to obligation.")
         }
-
-        // Checks the payment settled.
-        // We only supply the linear ID because this flow can be called from the shell on its own.
-        return subFlow(SendToSettlementOracle(linearId, SENDING.childProgressTracker())).tx
     }
-
 }

cordapp/src/main/kotlin/com/r3/corda/finance/obligation/client/flows/SendToSettlementOracle.kt

@@ -42,9 +42,12 @@ class SendToSettlementOracle(
         val obligationState = obligationStateAndRef.state.data
         val settlementMethod = obligationState.settlementMethod as OffLedgerPayment<*>
 
+        val settlementOracle = settlementMethod.settlementOracle
+                ?: throw IllegalArgumentException("Settlement Oracle must not be null")
+
         // Send the Oracle the ObligationContract state.
         progressTracker.currentStep = SENDING
-        val session = initiateFlow(settlementMethod.settlementOracle)
+        val session = initiateFlow(settlementOracle)
         subFlow(SendStateAndRefFlow(session, listOf(obligationStateAndRef)))
 
         // Receive a SignedTransaction from the oracle that exits the obligation, or throw an exception if we timed out.
@@ -53,7 +56,7 @@ class SendToSettlementOracle(
             when (it) {
                 is SettlementOracleResult.Success -> {
                     val stx = it.stx
-                    subFlow(FinalityFlow(stx, FINALISING.childProgressTracker()))
+                    subFlow(FinalityFlow(stx, setOf(session), FINALISING.childProgressTracker()))
                 }
                 is SettlementOracleResult.Failure -> {
                     throw IllegalStateException(it.message)